Tweaked the code better

Signed-off-by: naveensrinivasan <[email protected]>
bitbomdev · Nov 26, 2024 · 7f7bc7c · 7f7bc7c
1 parent 58db48d
commit 7f7bc7c
Show file tree

Hide file tree

Showing 4 changed files with 48 additions and 30 deletions.
diff --git a/api/v1/service.go b/api/v1/service.go
@@ -48,41 +48,41 @@ type Query struct {
 func (s *Service) GetNode(ctx context.Context, req *connect.Request[service.GetNodeRequest]) (*connect.Response[service.GetNodeResponse], error) {
 	node, err := s.storage.GetNode(req.Msg.Id)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get node by id: %w", err)
 	}
 	serviceNode, err := NodeToServiceNode(node)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to convert node to service node: %w", err)
 	}
 	return connect.NewResponse(&service.GetNodeResponse{Node: serviceNode}), nil
 }
 
 func (s *Service) GetNodeByName(ctx context.Context, req *connect.Request[service.GetNodeByNameRequest]) (*connect.Response[service.GetNodeByNameResponse], error) {
 	id, err := s.storage.NameToID(req.Msg.Name)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get node by name: %w", err)
 	}
 	node, err := s.storage.GetNode(id)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get node by id: %w", err)
 	}
 	serviceNode, err := NodeToServiceNode(node)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to convert node to service node: %w", err)
 	}
 	return connect.NewResponse(&service.GetNodeByNameResponse{Node: serviceNode}), nil
 }
 
 func (s *Service) GetNodesByGlob(ctx context.Context, req *connect.Request[service.GetNodesByGlobRequest]) (*connect.Response[service.GetNodesByGlobResponse], error) {
 	nodes, err := s.storage.GetNodesByGlob(req.Msg.Pattern)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get nodes by glob: %w", err)
 	}
 	serviceNodes := make([]*service.Node, 0, len(nodes))
 	for _, node := range nodes {
 		serviceNode, err := NodeToServiceNode(node)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("failed to convert node to service node: %w", err)
 		}
 		serviceNodes = append(serviceNodes, serviceNode)
 	}
@@ -92,11 +92,11 @@ func (s *Service) GetNodesByGlob(ctx context.Context, req *connect.Request[servi
 func (s *Service) AddNode(ctx context.Context, req *connect.Request[service.AddNodeRequest]) (*connect.Response[service.AddNodeResponse], error) {
 	resultNode, err := graph.AddNode(s.storage, req.Msg.Node.Type, req.Msg.Node.Metadata, req.Msg.Node.Name)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to add node: %w", err)
 	}
 	serviceNode, err := NodeToServiceNode(resultNode)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to convert node to service node: %w", err)
 	}
 	return connect.NewResponse(&service.AddNodeResponse{Node: serviceNode}), nil
 }
@@ -120,23 +120,23 @@ func (s *Service) SetDependency(ctx context.Context, req *connect.Request[servic
 func (s *Service) Cache(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
 	err := graph.Cache(s.storage)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to cache: %w", err)
 	}
 	return connect.NewResponse(&emptypb.Empty{}), nil
 }
 
 func (s *Service) Clear(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[emptypb.Empty], error) {
 	err := s.storage.RemoveAllCaches()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to clear: %w", err)
 	}
 	return connect.NewResponse(&emptypb.Empty{}), nil
 }
 
 func (s *Service) CustomLeaderboard(ctx context.Context, req *connect.Request[service.CustomLeaderboardRequest]) (*connect.Response[service.CustomLeaderboardResponse], error) {
 	uncachedNodes, err := s.storage.ToBeCached()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get uncached nodes: %w", err)
 	}
 	if len(uncachedNodes) != 0 {
 		return nil, fmt.Errorf("cannot use sorted leaderboards without caching")
@@ -239,18 +239,18 @@ func (s *Service) CustomLeaderboard(ctx context.Context, req *connect.Request[se
 func (s *Service) AllKeys(ctx context.Context, req *connect.Request[emptypb.Empty]) (*connect.Response[service.AllKeysResponse], error) {
 	keys, err := s.storage.GetAllKeys()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get all keys: %w", err)
 	}
 	nodes, err := s.storage.GetNodes(keys)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get nodes by keys: %w", err)
 	}
 
 	resultNodes := make([]*service.Node, 0, len(nodes))
 	for _, node := range nodes {
 		query, err := NodeToServiceNode(node)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("failed to convert node to service node: %w", err)	
 		}
 		resultNodes = append(resultNodes, query)
 	}
@@ -266,37 +266,37 @@ func (s *Service) Query(ctx context.Context, req *connect.Request[service.QueryR
 	}
 	keys, err := s.storage.GetAllKeys()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get all keys: %w", err)
 	}
 
 	nodes, err := s.storage.GetNodes(keys)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get nodes by keys: %w", err)
 	}
 
 	caches, err := s.storage.GetCaches(keys)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get caches by keys: %w", err)
 	}
 	cacheStack, err := s.storage.ToBeCached()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get to be cached nodes: %w", err)
 	}
 	result, err := graph.ParseAndExecute(req.Msg.Script, s.storage, "", nodes, caches, len(cacheStack) == 0)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to parse and execute script: %w", err)
 	}
 
 	outputNodes, err := s.storage.GetNodes(result.ToArray())
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get nodes by ids: %w", err)
 	}
 
 	resultNodes := make([]*service.Node, 0, len(outputNodes))
 	for _, node := range outputNodes {
 		query, err := NodeToServiceNode(node)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("failed to convert node to service node: %w", err)
 		}
 		resultNodes = append(resultNodes, query)
 	}
@@ -315,23 +315,23 @@ func (s *Service) Check(ctx context.Context, req *connect.Request[emptypb.Empty]
 func (s *Service) IngestSBOM(ctx context.Context, req *connect.Request[service.IngestSBOMRequest]) (*connect.Response[emptypb.Empty], error) {
 	err := ingest.SBOM(s.storage, req.Msg.Sbom)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to ingest sbom: %w", err)
 	}
 	return connect.NewResponse(&emptypb.Empty{}), nil
 }
 
 func (s *Service) IngestVulnerability(ctx context.Context, req *connect.Request[service.IngestVulnerabilityRequest]) (*connect.Response[emptypb.Empty], error) {
 	err := ingest.Vulnerabilities(s.storage, req.Msg.Vulnerability)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to ingest vulnerability: %w", err)
 	}
 	return connect.NewResponse(&emptypb.Empty{}), nil
 }
 
 func (s *Service) IngestScorecard(ctx context.Context, req *connect.Request[service.IngestScorecardRequest]) (*connect.Response[emptypb.Empty], error) {
 	err := ingest.Scorecards(s.storage, req.Msg.Scorecard)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to ingest scorecard: %w", err)
 	}
 	return connect.NewResponse(&emptypb.Empty{}), nil
 }

diff --git a/api/v1/service_test.go b/api/v1/service_test.go
@@ -198,17 +198,22 @@ func TestAddNode(t *testing.T) {
 	require.NoError(t, err)
 	assert.NotNil(t, resp.Msg.Node)
 	assert.Equal(t, "test_node", resp.Msg.Node.Name)
+
+	getNodeReq = connect.NewRequest(&service.GetNodeByNameRequest{Name: "nonexistent_node"})
+	resp, err = s.GetNodeByName(context.Background(), getNodeReq)
+	require.Error(t, err)
+	assert.Nil(t, resp)
 }
 
 func TestSetDependency(t *testing.T) {
 	s := setupService()
 	addNodeReq := connect.NewRequest(&service.AddNodeRequest{
-		Node: &service.Node{Name: "test_node"},
+		Node: &service.Node{Name: "test_node", Type: "type1"},
 	})
 	node1, err := s.AddNode(context.Background(), addNodeReq)
 	require.NoError(t, err)
 	addNodeReq2 := connect.NewRequest(&service.AddNodeRequest{
-		Node: &service.Node{Name: "test_node2"},
+		Node: &service.Node{Name: "test_node2", Type: "type1"},
 	})
 	node2, err := s.AddNode(context.Background(), addNodeReq2)
 	require.NoError(t, err)
@@ -222,7 +227,16 @@ func TestSetDependency(t *testing.T) {
 	resp, err := s.GetNodeByName(context.Background(), getNodeReq)
 	require.NoError(t, err)
 	assert.NotNil(t, resp.Msg.Node)
+	assert.NotEmpty(t, resp.Msg.Node.Dependencies, "Dependencies slice should not be empty")
 	assert.Equal(t, resp.Msg.Node.Dependencies[0], node2.Msg.Node.Id)
+	t.Run("non-existent node", func(t *testing.T) {
+		invalidReq := connect.NewRequest(&service.SetDependencyRequest{
+			NodeId:       0,
+			DependencyID: node2.Msg.Node.Id,
+		})
+		_, err = s.SetDependency(context.Background(), invalidReq)
+		assert.Error(t, err)
+	})
 }
 
 func TestHealthCheck(t *testing.T) {

diff --git a/pkg/tools/ingest/helpers.go b/pkg/tools/ingest/helpers.go
@@ -1,6 +1,10 @@
 package ingest
 
-import "github.com/package-url/packageurl-go"
+import (
+	"fmt"
+
+	"github.com/package-url/packageurl-go"
+)
 
 type Ecosystem string
 
@@ -69,7 +73,7 @@ func getPURLEcosystem(pkgURL packageurl.PackageURL) Ecosystem {
 func PURLToPackage(purl string) (PackageInfo, error) {
 	parsedPURL, err := packageurl.FromString(purl)
 	if err != nil {
-		return PackageInfo{}, err
+		return PackageInfo{}, fmt.Errorf("failed to parse purl: %w", err)
 	}
 	ecosystem := getPURLEcosystem(parsedPURL)
 

diff --git a/pkg/tools/ingest/vuln.go b/pkg/tools/ingest/vuln.go
@@ -103,7 +103,7 @@ func Vulnerabilities(storage graph.Storage, data []byte) error {
 
 	keys, err := storage.GetAllKeys()
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to get all keys: %w", err)
 	}
 
 	nodes, err := storage.GetNodes(keys)