label_service_test.go

Documentation: edge-infra.dev/pkg/edge/api/services

     1  package services
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"fmt"
     7  	"testing"
     8  
     9  	"github.com/DATA-DOG/go-sqlmock"
    10  	"github.com/lib/pq"
    11  	"github.com/stretchr/testify/assert"
    12  
    13  	"edge-infra.dev/pkg/edge/api/graph/model"
    14  	"edge-infra.dev/pkg/edge/api/services/artifacts"
    15  	clustersvc "edge-infra.dev/pkg/edge/api/services/cluster"
    16  	clusterlabel "edge-infra.dev/pkg/edge/api/services/cluster/label"
    17  	sqlquery "edge-infra.dev/pkg/edge/api/sql"
    18  	"edge-infra.dev/pkg/edge/capabilities"
    19  	"edge-infra.dev/pkg/edge/constants/api/fleet"
    20  	"edge-infra.dev/pkg/lib/runtime/version"
    21  )
    22  
    23  var testLabelClusterEdgeID = "test-label-cluster-edge-id"
    24  var testLabelID = "123456"
    25  var testLabelID2 = "123457"
    26  var testLabelID3 = "123458"
    27  var testLabelID4 = "123459"
    28  var artifactName = "virtual-machines"
    29  
    30  func TestDeleteLabelSQLEntry(t *testing.T) {
    31  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
    32  	if err != nil {
    33  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
    34  	}
    35  	defer db.Close()
    36  
    37  	mock.ExpectExec(sqlquery.LabelDeleteQuery).WithArgs(testLabelID).
    38  		WillReturnResult(sqlmock.NewResult(1, 1))
    39  
    40  	artifactsService := artifacts.NewArtifactsService(db, nil)
    41  	service := NewLabelService(artifactsService, db)
    42  
    43  	assert.NoError(t, service.DeleteLabels(context.Background(), testLabelID))
    44  
    45  	assert.NoError(t, mock.ExpectationsWereMet())
    46  }
    47  
    48  func TestDeleteClusterLabelSQLEntrySadPath(t *testing.T) {
    49  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
    50  	if err != nil {
    51  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
    52  	}
    53  	defer db.Close()
    54  
    55  	// Delete "edge-fleet" label from this cluster
    56  	mock.ExpectBegin()
    57  	mock.ExpectQuery(fmt.Sprintf(sqlquery.ClusterLabelDeleteQuery, sqlquery.WhereClusterEdgeIDAndLabelID)).WithArgs(testLabelClusterEdgeID, testLabelID).
    58  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id", "label_edge_id"}).
    59  			AddRow(testLabelClusterEdgeID, testLabelID))
    60  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
    61  		AddRow(testLabelID, "store", "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", "edge-fleet"))
    62  	mock.ExpectRollback()
    63  
    64  	// Delete "edge-type" label from this cluster
    65  	mock.ExpectBegin()
    66  	mock.ExpectQuery(fmt.Sprintf(sqlquery.ClusterLabelDeleteQuery, sqlquery.WhereClusterEdgeIDAndLabelID)).WithArgs(testLabelClusterEdgeID, testLabelID).
    67  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id", "label_edge_id"}).
    68  			AddRow(testLabelClusterEdgeID, testLabelID))
    69  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
    70  		AddRow(testLabelID, "generic", "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", "edge-type"))
    71  	mock.ExpectRollback()
    72  
    73  	artifactsService := artifacts.NewArtifactsService(db, nil)
    74  	service := NewLabelService(artifactsService, db)
    75  
    76  	assert.Error(t, service.DeleteClusterLabels(context.Background(), nil, nil), "error was expected while deleting label without providing cluster_edge_id or label_id")
    77  
    78  	// return an error when labelEdgeID is empty
    79  	var empty = ""
    80  	assert.Error(t, service.DeleteClusterLabels(context.Background(), &testLabelClusterEdgeID, &empty))
    81  	assert.Error(t, service.DeleteClusterLabels(context.Background(), &testLabelClusterEdgeID, nil))
    82  
    83  	assert.Error(t, service.DeleteClusterLabels(context.Background(), &testLabelClusterEdgeID, &testLabelID))
    84  	assert.Error(t, service.DeleteClusterLabels(context.Background(), &testLabelClusterEdgeID, &testLabelID))
    85  
    86  	assert.NoError(t, mock.ExpectationsWereMet())
    87  }
    88  
    89  func TestDeleteClusterLabelSQLEntry(t *testing.T) {
    90  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
    91  	if err != nil {
    92  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
    93  	}
    94  	defer db.Close()
    95  
    96  	// Delete label from every cluster
    97  	mock.ExpectBegin()
    98  	mock.ExpectQuery(fmt.Sprintf(sqlquery.ClusterLabelDeleteQuery, sqlquery.WhereLabelID)).WithArgs(testLabelID).
    99  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id", "label_edge_id"}).
   100  			AddRow("85b30e25-044b-47df-a3c6-ee35ce13da11", testLabelID).
   101  			AddRow("00ab4628-457d-4f65-be6f-01029189de11", testLabelID).
   102  			AddRow("1aa952d3-1123-435d-a433-d28304362cbb", testLabelID).
   103  			AddRow("9c7e6c1b-1c0f-4b54-8571-46ba15357594", testLabelID))
   104  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   105  		AddRow(testLabelID, "foo", "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", "foo"))
   106  	mock.ExpectCommit()
   107  
   108  	// Delete edge capability label from every cluster
   109  	mock.ExpectBegin()
   110  	mock.ExpectQuery(fmt.Sprintf(sqlquery.ClusterLabelDeleteQuery, sqlquery.WhereLabelID)).WithArgs(testLabelID).
   111  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id", "label_edge_id"}).
   112  			AddRow("85b30e25-044b-47df-a3c6-ee35ce13da11", testLabelID).
   113  			AddRow("00ab4628-457d-4f65-be6f-01029189de11", testLabelID).
   114  			AddRow("1aa952d3-1123-435d-a433-d28304362cbb", testLabelID).
   115  			AddRow("9c7e6c1b-1c0f-4b54-8571-46ba15357594", testLabelID))
   116  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   117  		AddRow(testLabelID, capabilities.EdgeCapabilities[0].ArtifactName, "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", capabilities.EdgeCapabilitiesLabel))
   118  	mock.ExpectQuery(sqlquery.GetClusterArtifactVersions).WithArgs("85b30e25-044b-47df-a3c6-ee35ce13da11").
   119  		WillReturnRows(mock.NewRows([]string{"artifact_name", "artifact_version"}).AddRow(artifactName, version.New().SemVer))
   120  	mock.ExpectExec(sqlquery.DeleteClusterArtifactVersion).WithArgs("85b30e25-044b-47df-a3c6-ee35ce13da11", artifactName).
   121  		WillReturnResult(sqlmock.NewResult(1, 1))
   122  	mock.ExpectQuery(sqlquery.GetClusterArtifactVersions).WithArgs("00ab4628-457d-4f65-be6f-01029189de11").
   123  		WillReturnRows(mock.NewRows([]string{"artifact_name", "artifact_version"}).AddRow(artifactName, version.New().SemVer))
   124  	mock.ExpectExec(sqlquery.DeleteClusterArtifactVersion).WithArgs("00ab4628-457d-4f65-be6f-01029189de11", artifactName).
   125  		WillReturnResult(sqlmock.NewResult(1, 1))
   126  	mock.ExpectQuery(sqlquery.GetClusterArtifactVersions).WithArgs("1aa952d3-1123-435d-a433-d28304362cbb").
   127  		WillReturnRows(mock.NewRows([]string{"artifact_name", "artifact_version"}).AddRow(artifactName, version.New().SemVer))
   128  	mock.ExpectExec(sqlquery.DeleteClusterArtifactVersion).WithArgs("1aa952d3-1123-435d-a433-d28304362cbb", artifactName).
   129  		WillReturnResult(sqlmock.NewResult(1, 1))
   130  	mock.ExpectQuery(sqlquery.GetClusterArtifactVersions).WithArgs("9c7e6c1b-1c0f-4b54-8571-46ba15357594").
   131  		WillReturnRows(mock.NewRows([]string{"artifact_name", "artifact_version"}).AddRow(artifactName, version.New().SemVer))
   132  	mock.ExpectExec(sqlquery.DeleteClusterArtifactVersion).WithArgs("9c7e6c1b-1c0f-4b54-8571-46ba15357594", artifactName).
   133  		WillReturnResult(sqlmock.NewResult(1, 1))
   134  	mock.ExpectCommit()
   135  
   136  	// Delete label from this cluster
   137  	mock.ExpectBegin()
   138  	mock.ExpectQuery(fmt.Sprintf(sqlquery.ClusterLabelDeleteQuery, sqlquery.WhereClusterEdgeIDAndLabelID)).WithArgs(testLabelClusterEdgeID, testLabelID).
   139  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id", "label_edge_id"}).
   140  			AddRow(testLabelClusterEdgeID, testLabelID))
   141  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   142  		AddRow(testLabelID, "foo", "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", "foo"))
   143  	mock.ExpectCommit()
   144  
   145  	// Delete edge capability label from this cluster
   146  	mock.ExpectBegin()
   147  	mock.ExpectQuery(fmt.Sprintf(sqlquery.ClusterLabelDeleteQuery, sqlquery.WhereClusterEdgeIDAndLabelID)).WithArgs(testLabelClusterEdgeID, testLabelID).
   148  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id", "label_edge_id"}).
   149  			AddRow(testLabelClusterEdgeID, testLabelID))
   150  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   151  		AddRow(testLabelID, capabilities.EdgeCapabilities[0].ArtifactName, "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", capabilities.EdgeCapabilitiesLabel))
   152  	mock.ExpectQuery(sqlquery.GetClusterArtifactVersions).WithArgs(testLabelClusterEdgeID).
   153  		WillReturnRows(mock.NewRows([]string{"artifact_name", "artifact_version"}).AddRow(artifactName, version.New().SemVer))
   154  	mock.ExpectExec(sqlquery.DeleteClusterArtifactVersion).WithArgs(testLabelClusterEdgeID, artifactName).
   155  		WillReturnResult(sqlmock.NewResult(1, 1))
   156  	mock.ExpectCommit()
   157  
   158  	clusterLabelSvc := clustersvc.NewLabelService(db)
   159  	artifactsService := artifacts.NewArtifactsService(db, clusterLabelSvc)
   160  	service := NewLabelService(artifactsService, db)
   161  
   162  	assert.NoError(t, service.DeleteClusterLabels(context.Background(), nil, &testLabelID))
   163  	assert.NoError(t, service.DeleteClusterLabels(context.Background(), nil, &testLabelID))
   164  	assert.NoError(t, service.DeleteClusterLabels(context.Background(), &testLabelClusterEdgeID, &testLabelID))
   165  	assert.NoError(t, service.DeleteClusterLabels(context.Background(), &testLabelClusterEdgeID, &testLabelID))
   166  
   167  	assert.NoError(t, mock.ExpectationsWereMet())
   168  }
   169  
   170  func TestLabelService_CreateClusterLabelSQLEntry_Sad(t *testing.T) {
   171  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   172  	if err != nil {
   173  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   174  	}
   175  	defer db.Close()
   176  
   177  	// label with uniqeness conflict
   178  	mock.ExpectBegin()
   179  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   180  		AddRow(testLabelID, capabilities.EdgeCapabilities[0].ArtifactName, "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", capabilities.EdgeCapabilitiesLabel))
   181  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID).
   182  		WillReturnResult(sqlmock.NewResult(1, 1))
   183  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueCount).WithArgs(testClusterEdgeID, capabilities.EdgeCapabilitiesLabel).WillReturnRows(mock.NewRows([]string{"count"}).AddRow(2))
   184  	mock.ExpectRollback()
   185  
   186  	// banner-wide label
   187  	mock.ExpectBegin()
   188  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   189  		AddRow(testLabelID, "foo", "#00000", true, false, "", true, "test label", "foo"))
   190  	mock.ExpectRollback()
   191  
   192  	// label with edge capabilities that is higher than the cluster version
   193  	mock.ExpectBegin()
   194  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   195  		AddRow(testLabelID, capabilities.EdgeCapabilities[0].ArtifactName, "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", capabilities.EdgeCapabilitiesLabel))
   196  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID).
   197  		WillReturnResult(sqlmock.NewResult(1, 1))
   198  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueCount).WithArgs(testClusterEdgeID, capabilities.EdgeCapabilitiesLabel).WillReturnRows(mock.NewRows([]string{"count"}).AddRow(1))
   199  	mock.ExpectQuery(sqlquery.GetClusterFleetVersion).WillReturnRows(mock.NewRows([]string{"fleet_version"}).AddRow("0.19.0"))
   200  
   201  	clusterLabelSvc := clustersvc.NewLabelService(db)
   202  	artifactsService := artifacts.NewArtifactsService(db, clusterLabelSvc)
   203  	service := NewLabelService(artifactsService, db)
   204  
   205  	assert.Error(t, service.CreateClusterLabel(context.Background(), testClusterEdgeID, testLabelID))
   206  	assert.Error(t, service.CreateClusterLabel(context.Background(), testClusterEdgeID, testLabelID))
   207  	assert.Error(t, service.CreateClusterLabel(context.Background(), testClusterEdgeID, testLabelID))
   208  }
   209  
   210  func TestLabelService_CreateClusterLabelSQLEntry(t *testing.T) {
   211  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   212  	if err != nil {
   213  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   214  	}
   215  	defer db.Close()
   216  
   217  	// label that is unique with edge capabilities
   218  	mock.ExpectBegin()
   219  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   220  		AddRow(testLabelID, capabilities.EdgeCapabilities[0].ArtifactName, "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", capabilities.EdgeCapabilitiesLabel))
   221  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID).
   222  		WillReturnResult(sqlmock.NewResult(1, 1))
   223  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueCount).WithArgs(testClusterEdgeID, capabilities.EdgeCapabilitiesLabel).WillReturnRows(mock.NewRows([]string{"count"}).AddRow(1))
   224  	mock.ExpectQuery(sqlquery.GetClusterFleetVersion).WillReturnRows(mock.NewRows([]string{"fleet_version"}).AddRow("0.21.0"))
   225  	mock.ExpectQuery(sqlquery.GetClusterArtifactVersions).WithArgs(testClusterEdgeID).
   226  		WillReturnRows(mock.NewRows([]string{"artifact_name", "artifact_version"}).AddRow(fleet.Store, version.New().SemVer))
   227  	mock.ExpectQuery(clusterlabel.FetchFleetType).WithArgs(testClusterEdgeID).
   228  		WillReturnRows(mock.NewRows([]string{"label_key"}).AddRow(fleet.Store))
   229  	mock.ExpectExec(sqlquery.CreateClusterArtifactVersion).WithArgs(testClusterEdgeID, artifactName, version.New().SemVer).WillReturnResult(sqlmock.NewResult(1, 1))
   230  	mock.ExpectCommit()
   231  
   232  	// label that is unique but is not edge capabilities
   233  	mock.ExpectBegin()
   234  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   235  		AddRow(testLabelID, "foo", "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", "foo"))
   236  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID).
   237  		WillReturnResult(sqlmock.NewResult(1, 1))
   238  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueCount).WithArgs(testClusterEdgeID, "foo").WillReturnRows(mock.NewRows([]string{"count"}).AddRow(1))
   239  	mock.ExpectCommit()
   240  
   241  	// label that is not unique
   242  	mock.ExpectBegin()
   243  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   244  		AddRow(testLabelID, "foo", "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", false, "test label", "foo"))
   245  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID).
   246  		WillReturnResult(sqlmock.NewResult(1, 1))
   247  	mock.ExpectCommit()
   248  
   249  	clusterLabelSvc := clustersvc.NewLabelService(db)
   250  	artifactsService := artifacts.NewArtifactsService(db, clusterLabelSvc)
   251  	service := NewLabelService(artifactsService, db)
   252  
   253  	assert.NoError(t, service.CreateClusterLabel(context.Background(), testClusterEdgeID, testLabelID))
   254  	assert.NoError(t, service.CreateClusterLabel(context.Background(), testClusterEdgeID, testLabelID))
   255  	assert.NoError(t, service.CreateClusterLabel(context.Background(), testClusterEdgeID, testLabelID))
   256  
   257  	assert.NoError(t, mock.ExpectationsWereMet())
   258  }
   259  
   260  func TestLabelService_CreateClusterLabels(t *testing.T) {
   261  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   262  	if err != nil {
   263  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   264  	}
   265  	defer db.Close()
   266  
   267  	// check that a failed insert rolls back entire call to CreateClusterLabels
   268  	mock.ExpectBegin()
   269  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   270  		AddRow(testLabelID, "test-label", "#00000", true, true, "f2af0c5b-7412-4f81-b024-1741e01700a3", false, "test label", ""))
   271  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID).
   272  		WillReturnResult(sqlmock.NewResult(1, 1))
   273  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   274  		AddRow(testLabelID2, capabilities.EdgeCapabilities[0].ArtifactName, "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", capabilities.EdgeCapabilitiesLabel))
   275  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID2).
   276  		WillReturnError(errors.New("error creating cluster label"))
   277  	mock.ExpectRollback()
   278  
   279  	// create a normal label (not unique), and a label with edge capabilities.
   280  	mock.ExpectBegin()
   281  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   282  		AddRow(testLabelID, "test-label", "#00000", true, true, "f2af0c5b-7412-4f81-b024-1741e01700a3", false, "test label", ""))
   283  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID).
   284  		WillReturnResult(sqlmock.NewResult(1, 1))
   285  	mock.ExpectQuery(sqlquery.GetLabelQuery).WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   286  		AddRow(testLabelID2, capabilities.EdgeCapabilities[0].ArtifactName, "#00000", true, false, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", capabilities.EdgeCapabilitiesLabel))
   287  	mock.ExpectExec(sqlquery.ClusterLabelInsertQuery).WithArgs(testClusterEdgeID, testLabelID2).
   288  		WillReturnResult(sqlmock.NewResult(1, 1))
   289  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueCount).WithArgs(testClusterEdgeID, capabilities.EdgeCapabilitiesLabel).WillReturnRows(mock.NewRows([]string{"count"}).AddRow(1))
   290  	mock.ExpectQuery(sqlquery.GetClusterFleetVersion).WillReturnRows(mock.NewRows([]string{"fleet_version"}).AddRow("0.21.0"))
   291  	mock.ExpectQuery(sqlquery.GetClusterArtifactVersions).WithArgs(testClusterEdgeID).
   292  		WillReturnRows(mock.NewRows([]string{"artifact_name", "artifact_version"}).AddRow(fleet.Store, version.New().SemVer))
   293  	mock.ExpectQuery(clusterlabel.FetchFleetType).WithArgs(testClusterEdgeID).
   294  		WillReturnRows(mock.NewRows([]string{"label_key"}).AddRow(fleet.Store))
   295  	mock.ExpectExec(sqlquery.CreateClusterArtifactVersion).WithArgs(testClusterEdgeID, artifactName, version.New().SemVer).WillReturnResult(sqlmock.NewResult(1, 1))
   296  	mock.ExpectCommit()
   297  
   298  	clusterLabelSvc := clustersvc.NewLabelService(db)
   299  	artifactsService := artifacts.NewArtifactsService(db, clusterLabelSvc)
   300  	service := NewLabelService(artifactsService, db)
   301  
   302  	assert.Error(t, service.CreateClusterLabels(context.Background(), testClusterEdgeID, []string{testLabelID, testLabelID2}))
   303  	assert.NoError(t, service.CreateClusterLabels(context.Background(), testClusterEdgeID, []string{testLabelID, testLabelID2}))
   304  	assert.NoError(t, mock.ExpectationsWereMet())
   305  }
   306  
   307  func TestGetClusterLabelSQLEntry(t *testing.T) {
   308  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   309  	if err != nil {
   310  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   311  	}
   312  	defer db.Close()
   313  
   314  	// get with cluster_edge_id
   315  	mock.ExpectQuery(fmt.Sprintf(sqlquery.GetClusterLabelsQuery, sqlquery.WhereClusterEdgeID)).WithArgs(&testLabelClusterEdgeID).
   316  		WillReturnRows(mock.NewRows([]string{"labelid", "cluster_edge_id"}).
   317  			AddRow(testLabelClusterEdgeID, testLabelID))
   318  
   319  	// get with label_edge_id
   320  	mock.ExpectQuery(fmt.Sprintf(sqlquery.GetClusterLabelsQuery, sqlquery.WhereLabelID)).WithArgs(&testLabelID).
   321  		WillReturnRows(mock.NewRows([]string{"labelid", "cluster_edge_id"}).
   322  			AddRow(testLabelClusterEdgeID, testLabelID).
   323  			AddRow(testLabelClusterEdgeID+"-2", testLabelID))
   324  
   325  	// get with cluster_edge_id and label_edge_id
   326  	mock.ExpectQuery(fmt.Sprintf(sqlquery.GetClusterLabelsQuery, sqlquery.WhereClusterEdgeIDAndLabelID)).WithArgs(&testLabelClusterEdgeID, &testLabelID).
   327  		WillReturnRows(mock.NewRows([]string{"labelid", "cluster_edge_id"}).
   328  			AddRow(testLabelClusterEdgeID, testLabelID))
   329  	artifactsService := artifacts.NewArtifactsService(db, nil)
   330  	service := NewLabelService(artifactsService, db)
   331  
   332  	vals, err := service.GetClusterLabels(context.Background(), &testLabelClusterEdgeID, nil)
   333  	assert.NoError(t, err)
   334  	assert.Equal(t, len(vals), 1)
   335  
   336  	vals, err = service.GetClusterLabels(context.Background(), nil, &testLabelID)
   337  	assert.NoError(t, err)
   338  	assert.Equal(t, len(vals), 2)
   339  
   340  	vals, err = service.GetClusterLabels(context.Background(), &testLabelClusterEdgeID, &testLabelID)
   341  	assert.NoError(t, err)
   342  	assert.Equal(t, len(vals), 1)
   343  
   344  	_, err = service.GetClusterLabels(context.Background(), nil, nil)
   345  	assert.Error(t, err, "cluster_edge_id and/or label_edge_id are required")
   346  
   347  	assert.NoError(t, mock.ExpectationsWereMet())
   348  }
   349  
   350  func TestCreateLabelSQLEntry_Sad(t *testing.T) {
   351  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   352  	if err != nil {
   353  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   354  	}
   355  	defer db.Close()
   356  
   357  	clusterLabelSvc := clustersvc.NewLabelService(db)
   358  	artifactsService := artifacts.NewArtifactsService(db, clusterLabelSvc)
   359  	service := NewLabelService(artifactsService, db)
   360  
   361  	// banner-wide label
   362  	assert.Error(t, service.CreateLabel(context.Background(), &model.LabelInput{
   363  		Key:          "foo",
   364  		Color:        "#123456",
   365  		Visible:      true,
   366  		Editable:     true,
   367  		BannerEdgeID: "",
   368  		Unique:       false,
   369  		Description:  "label description",
   370  		Type:         "foo",
   371  	}))
   372  
   373  	// unique label with missing type
   374  	assert.Error(t, service.CreateLabel(context.Background(), &model.LabelInput{
   375  		Key:          "baz",
   376  		Color:        "#123456",
   377  		Visible:      true,
   378  		Editable:     true,
   379  		BannerEdgeID: "test-tenant",
   380  		Unique:       true,
   381  		Description:  "label description",
   382  		Type:         "",
   383  	}))
   384  
   385  	// label using reserved type values
   386  	labelReservedType := &model.LabelInput{
   387  		Key:          "bar",
   388  		Color:        "#123456",
   389  		Visible:      true,
   390  		Editable:     true,
   391  		BannerEdgeID: "test-tenant",
   392  		Unique:       false,
   393  		Description:  "label description",
   394  	}
   395  
   396  	labelReservedType.Type = "edge-type"
   397  	assert.Error(t, service.CreateLabel(context.Background(), labelReservedType))
   398  
   399  	labelReservedType.Type = "edge-fleet"
   400  	assert.Error(t, service.CreateLabel(context.Background(), labelReservedType))
   401  
   402  	assert.NoError(t, mock.ExpectationsWereMet())
   403  }
   404  
   405  func TestCreateLabelSQLEntry(t *testing.T) {
   406  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   407  	if err != nil {
   408  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   409  	}
   410  	defer db.Close()
   411  	labelVisible := &model.LabelInput{
   412  		Key:          "test-label",
   413  		Color:        "#123456",
   414  		Visible:      true,
   415  		Editable:     true,
   416  		BannerEdgeID: "test-tenant",
   417  		Unique:       false,
   418  		Description:  "label description",
   419  		Type:         "label type",
   420  	}
   421  
   422  	labelNotVisible := &model.LabelInput{
   423  		Key:          "test-label",
   424  		Color:        "#123456",
   425  		Visible:      false,
   426  		Editable:     true,
   427  		BannerEdgeID: "test-tenant",
   428  		Unique:       false,
   429  		Description:  "label description",
   430  		Type:         "label type",
   431  	}
   432  
   433  	// create visible label
   434  	mock.ExpectExec(sqlquery.LabelInsertQuery).WithArgs(labelVisible.Key, labelVisible.Color, labelVisible.Visible, labelVisible.Editable, labelVisible.BannerEdgeID, labelVisible.Unique, labelVisible.Description, labelVisible.Type).
   435  		WillReturnResult(sqlmock.NewResult(1, 1))
   436  
   437  	// create non-visible label
   438  	mock.ExpectExec(sqlquery.LabelInsertQuery).WithArgs(labelNotVisible.Key, labelNotVisible.Color, labelNotVisible.Visible, labelNotVisible.Editable, labelNotVisible.BannerEdgeID, labelNotVisible.Unique, labelNotVisible.Description, labelNotVisible.Type).
   439  		WillReturnResult(sqlmock.NewResult(1, 1))
   440  
   441  	clusterLabelSvc := clustersvc.NewLabelService(db)
   442  	artifactsService := artifacts.NewArtifactsService(db, clusterLabelSvc)
   443  	service := NewLabelService(artifactsService, db)
   444  
   445  	assert.NoError(t, service.CreateLabel(context.Background(), labelVisible))
   446  	assert.NoError(t, service.CreateLabel(context.Background(), labelNotVisible))
   447  
   448  	assert.NoError(t, mock.ExpectationsWereMet())
   449  }
   450  
   451  func TestUpdateLabelSQLEntry_Sad(t *testing.T) {
   452  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   453  	if err != nil {
   454  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   455  	}
   456  	defer db.Close()
   457  	label := &model.LabelUpdateInput{
   458  		LabelEdgeID: testLabelID,
   459  		LabelValues: &model.LabelInput{
   460  			Key:          "test-label",
   461  			Color:        "#123456",
   462  			Editable:     true,
   463  			Visible:      false,
   464  			BannerEdgeID: "test-tenant",
   465  			Unique:       false,
   466  			Description:  "label description",
   467  			Type:         "label type",
   468  		},
   469  	}
   470  	newType := "some other type"
   471  
   472  	// update banner-wide label
   473  	mock.ExpectBegin()
   474  	mock.ExpectQuery(sqlquery.GetLabelQuery).WithArgs(label.LabelEdgeID).
   475  		WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   476  			AddRow(label.LabelEdgeID, label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, "", label.LabelValues.Unique, label.LabelValues.Description, label.LabelValues.Type))
   477  	mock.ExpectRollback()
   478  
   479  	// set label unique to true
   480  	mock.ExpectBegin()
   481  	mock.ExpectQuery(sqlquery.GetLabelQuery).WithArgs(label.LabelEdgeID).
   482  		WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   483  			AddRow(label.LabelEdgeID, label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, label.LabelValues.Unique, label.LabelValues.Description, label.LabelValues.Type))
   484  	mock.ExpectExec(sqlquery.LabelUpdateQuery).WithArgs(label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, true, label.LabelValues.Description, label.LabelValues.Type, label.LabelEdgeID).
   485  		WillReturnResult(sqlmock.NewResult(1, 1))
   486  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueConflicts).WithArgs(label.LabelValues.Type).
   487  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id"}).
   488  			AddRow(testClusterEdgeID))
   489  	mock.ExpectRollback()
   490  
   491  	// set label type whose unique value is already true
   492  	mock.ExpectBegin()
   493  	mock.ExpectQuery(sqlquery.GetLabelQuery).WithArgs(label.LabelEdgeID).
   494  		WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   495  			AddRow(label.LabelEdgeID, label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, true, label.LabelValues.Description, label.LabelValues.Type))
   496  	mock.ExpectExec(sqlquery.LabelUpdateQuery).WithArgs(label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, true, label.LabelValues.Description, newType, label.LabelEdgeID).
   497  		WillReturnResult(sqlmock.NewResult(1, 1))
   498  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueConflicts).WithArgs(newType).
   499  		WillReturnRows(mock.NewRows([]string{"cluster_edge_id"}).
   500  			AddRow(testClusterEdgeID))
   501  	mock.ExpectRollback()
   502  
   503  	artifactsService := artifacts.NewArtifactsService(db, nil)
   504  	service := NewLabelService(artifactsService, db)
   505  
   506  	assert.Error(t, service.UpdateLabel(context.Background(), label))
   507  
   508  	label.LabelValues.Unique = true
   509  	assert.Error(t, service.UpdateLabel(context.Background(), label))
   510  	label.LabelValues.Type = newType
   511  	assert.Error(t, service.UpdateLabel(context.Background(), label))
   512  
   513  	// invalid label input will return an error before any sql queries are executed.
   514  	label.LabelValues.BannerEdgeID = ""
   515  	assert.Error(t, service.UpdateLabel(context.Background(), label))
   516  
   517  	assert.NoError(t, mock.ExpectationsWereMet())
   518  }
   519  
   520  func TestUpdateLabelSQLEntry(t *testing.T) {
   521  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   522  	if err != nil {
   523  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   524  	}
   525  	defer db.Close()
   526  	label := &model.LabelUpdateInput{
   527  		LabelEdgeID: testLabelID,
   528  		LabelValues: &model.LabelInput{
   529  			Key:          "test-label",
   530  			Color:        "#123456",
   531  			Editable:     true,
   532  			Visible:      false,
   533  			BannerEdgeID: "test-tenant",
   534  			Unique:       false,
   535  			Description:  "label description",
   536  			Type:         "label type",
   537  		},
   538  	}
   539  	newType := "some other type"
   540  
   541  	// normal label
   542  	mock.ExpectBegin()
   543  	mock.ExpectQuery(sqlquery.GetLabelQuery).WithArgs(label.LabelEdgeID).
   544  		WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   545  			AddRow(label.LabelEdgeID, label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, label.LabelValues.Unique, label.LabelValues.Description, label.LabelValues.Type))
   546  	mock.ExpectExec(sqlquery.LabelUpdateQuery).WithArgs(label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, label.LabelValues.Unique, label.LabelValues.Description, label.LabelValues.Type, label.LabelEdgeID).
   547  		WillReturnResult(sqlmock.NewResult(1, 1))
   548  	mock.ExpectCommit()
   549  
   550  	// set label unique to true (happy path)
   551  	mock.ExpectBegin()
   552  	mock.ExpectQuery(sqlquery.GetLabelQuery).WithArgs(label.LabelEdgeID).
   553  		WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   554  			AddRow(label.LabelEdgeID, label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, label.LabelValues.Unique, label.LabelValues.Description, label.LabelValues.Type))
   555  	mock.ExpectExec(sqlquery.LabelUpdateQuery).WithArgs(label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, true, label.LabelValues.Description, label.LabelValues.Type, label.LabelEdgeID).
   556  		WillReturnResult(sqlmock.NewResult(1, 1))
   557  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueConflicts).WithArgs(label.LabelValues.Type).
   558  		WillReturnRows(sqlmock.NewRows([]string{"cluster_edge_id"})) // no rows
   559  	mock.ExpectCommit()
   560  
   561  	// set label type whose unique value is already true (happy path)
   562  	mock.ExpectBegin()
   563  	mock.ExpectQuery(sqlquery.GetLabelQuery).WithArgs(label.LabelEdgeID).
   564  		WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   565  			AddRow(label.LabelEdgeID, label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, true, label.LabelValues.Description, label.LabelValues.Type))
   566  	mock.ExpectExec(sqlquery.LabelUpdateQuery).WithArgs(label.LabelValues.Key, label.LabelValues.Color, label.LabelValues.Visible, label.LabelValues.Editable, label.LabelValues.BannerEdgeID, true, label.LabelValues.Description, newType, label.LabelEdgeID).
   567  		WillReturnResult(sqlmock.NewResult(1, 1))
   568  	mock.ExpectQuery(sqlquery.SelectClusterLabelsUniqueConflicts).WithArgs(newType).
   569  		WillReturnRows(sqlmock.NewRows([]string{"cluster_edge_id"})) // no rows
   570  	mock.ExpectCommit()
   571  
   572  	artifactsService := artifacts.NewArtifactsService(db, nil)
   573  	service := NewLabelService(artifactsService, db)
   574  
   575  	assert.NoError(t, service.UpdateLabel(context.Background(), label))
   576  
   577  	label.LabelValues.Unique = true
   578  	assert.NoError(t, service.UpdateLabel(context.Background(), label))
   579  
   580  	label.LabelValues.Type = newType
   581  	assert.NoError(t, service.UpdateLabel(context.Background(), label))
   582  
   583  	assert.NoError(t, mock.ExpectationsWereMet())
   584  }
   585  
   586  func TestGetLabelSQLEntry(t *testing.T) {
   587  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   588  	if err != nil {
   589  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   590  	}
   591  	defer db.Close()
   592  	b := "test-tenant"
   593  	labelVisible := &model.Label{
   594  		LabelEdgeID:  testLabelID,
   595  		Key:          "test-label",
   596  		Color:        "#123456",
   597  		Visible:      true,
   598  		BannerEdgeID: &b,
   599  		Unique:       false,
   600  		Description:  "label description",
   601  		Type:         "label type",
   602  	}
   603  	nb := ""
   604  	labelNoBanner := &model.Label{
   605  		LabelEdgeID:  testLabelID2,
   606  		Key:          "test-label",
   607  		Color:        "#123456",
   608  		Visible:      true,
   609  		BannerEdgeID: &nb,
   610  		Unique:       false,
   611  		Description:  "label description",
   612  		Type:         "label type",
   613  	}
   614  
   615  	mock.ExpectQuery(sqlquery.GetLabelsByBannerQuery).
   616  		WithArgs(b).
   617  		WillReturnRows(mock.NewRows([]string{"labelid", "labelkey", "color", "visible", "editable", "banner", "unique", "description", "label_type"}).
   618  			AddRow(labelVisible.LabelEdgeID, labelVisible.Key, labelVisible.Color, labelVisible.Visible, labelVisible.Editable, labelVisible.BannerEdgeID, labelVisible.Unique, labelVisible.Description, labelVisible.Type))
   619  	mock.ExpectQuery(sqlquery.GetNoBannerLabelsQuery).
   620  		WillReturnRows(mock.NewRows([]string{"labelid", "labelkey", "color", "visible", "editable", "banner", "unique", "description", "label_type"}).
   621  			AddRow(labelNoBanner.LabelEdgeID, labelNoBanner.Key, labelNoBanner.Color, labelNoBanner.Visible, labelNoBanner.Editable, labelNoBanner.BannerEdgeID, labelNoBanner.Unique, labelNoBanner.Description, labelNoBanner.Type))
   622  	mock.ExpectQuery(sqlquery.GetLabelsQuery).
   623  		WillReturnRows(mock.NewRows([]string{"labelid", "labelkey", "color", "visible", "editable", "banner", "unique", "description", "label_type"}).
   624  			AddRow(labelNoBanner.LabelEdgeID, labelNoBanner.Key, labelNoBanner.Color, labelNoBanner.Visible, labelNoBanner.Editable, labelNoBanner.BannerEdgeID, labelNoBanner.Unique, labelNoBanner.Description, labelNoBanner.Type).
   625  			AddRow(labelVisible.LabelEdgeID, labelVisible.Key, labelVisible.Color, labelVisible.Visible, labelVisible.Editable, labelVisible.BannerEdgeID, labelVisible.Unique, labelVisible.Description, labelVisible.Type))
   626  
   627  	artifactsService := artifacts.NewArtifactsService(db, nil)
   628  	service := NewLabelService(artifactsService, db)
   629  
   630  	labels, err := service.GetLabels(context.Background(), labelVisible.BannerEdgeID)
   631  	assert.NoError(t, err)
   632  	assert.Equal(t, len(labels), 1)
   633  	assert.Equal(t, labelVisible.LabelEdgeID, labels[0].LabelEdgeID)
   634  	assert.Equal(t, labelVisible.Key, labels[0].Key)
   635  	assert.Equal(t, labelVisible.Color, labels[0].Color)
   636  	assert.Equal(t, labelVisible.Visible, labels[0].Visible)
   637  	assert.Equal(t, labelVisible.BannerEdgeID, labels[0].BannerEdgeID)
   638  
   639  	labels, err = service.GetLabels(context.Background(), labelNoBanner.BannerEdgeID)
   640  	assert.NoError(t, err)
   641  	assert.Equal(t, len(labels), 1)
   642  	assert.Equal(t, labelNoBanner.LabelEdgeID, labels[0].LabelEdgeID)
   643  	assert.Equal(t, labelNoBanner.Key, labels[0].Key)
   644  	assert.Equal(t, labelNoBanner.Color, labels[0].Color)
   645  	assert.Equal(t, labelNoBanner.Visible, labels[0].Visible)
   646  	assert.Equal(t, labelNoBanner.BannerEdgeID, labels[0].BannerEdgeID)
   647  
   648  	labels, err = service.GetLabels(context.Background(), nil)
   649  	assert.NoError(t, err)
   650  	assert.Equal(t, len(labels), 2)
   651  
   652  	assert.NoError(t, mock.ExpectationsWereMet())
   653  }
   654  
   655  func TestGetLabelTypes(t *testing.T) {
   656  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   657  	if err != nil {
   658  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   659  	}
   660  	defer db.Close()
   661  	testBanner := "test-banner"
   662  	mock.ExpectQuery(sqlquery.SelectLabelTypesByBanner).
   663  		WithArgs(testBanner).
   664  		WillReturnRows(mock.NewRows([]string{"label_type"}).
   665  			AddRow(pq.Array([]string{"type1", "type2", "type3"})))
   666  
   667  	artifactsService := artifacts.NewArtifactsService(db, nil)
   668  	service := NewLabelService(artifactsService, db)
   669  
   670  	typs, err := service.GetLabelTypes(context.Background(), &testBanner)
   671  	assert.NoError(t, err)
   672  	assert.Equal(t, 3, len(typs))
   673  	assert.Equal(t, typs[0], "type1")
   674  	assert.Equal(t, typs[1], "type2")
   675  	assert.Equal(t, typs[2], "type3")
   676  
   677  	mock.ExpectQuery(sqlquery.SelectLabelTypes).
   678  		WillReturnRows(mock.NewRows([]string{"label_type"}).
   679  			AddRow(pq.Array([]string{})))
   680  
   681  	typs, err = service.GetLabelTypes(context.Background(), nil)
   682  	assert.NoError(t, err)
   683  	assert.Equal(t, []string{}, typs)
   684  }
   685  
   686  func TestGetLabelTypesNoBanner(t *testing.T) {
   687  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   688  	if err != nil {
   689  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   690  	}
   691  	defer db.Close()
   692  	mock.ExpectQuery(sqlquery.SelectLabelTypes).
   693  		WillReturnRows(mock.NewRows([]string{"label_type"}).
   694  			AddRow(pq.Array([]string{"type1", "type2", "type3"})))
   695  
   696  	artifactsService := artifacts.NewArtifactsService(db, nil)
   697  	service := NewLabelService(artifactsService, db)
   698  
   699  	typs, err := service.GetLabelTypes(context.Background(), nil)
   700  	assert.NoError(t, err)
   701  	assert.Equal(t, 3, len(typs))
   702  	assert.Equal(t, typs[0], "type1")
   703  	assert.Equal(t, typs[1], "type2")
   704  	assert.Equal(t, typs[2], "type3")
   705  }
   706  
   707  func TestGetLabel(t *testing.T) {
   708  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   709  	if err != nil {
   710  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   711  	}
   712  	defer db.Close()
   713  
   714  	mock.ExpectQuery(sqlquery.GetLabelQuery).
   715  		WillReturnRows(mock.NewRows([]string{"label_edge_id", "label_key", "color", "visible", "editable", "banner_edge_id", "label_unique", "description", "label_type"}).
   716  			AddRow("de3bacfb-1600-4665-bcda-a6ef19c8206b", "test-label", "#00000", true, true, "f2af0c5b-7412-4f81-b024-1741e01700a3", true, "test label", ""))
   717  
   718  	artifactsService := artifacts.NewArtifactsService(db, nil)
   719  	service := NewLabelService(artifactsService, db)
   720  
   721  	label, err := service.GetLabel(context.Background(), "de3bacfb-1600-4665-bcda-a6ef19c8206b")
   722  	assert.NoError(t, err)
   723  	assert.Equal(t, label.LabelEdgeID, "de3bacfb-1600-4665-bcda-a6ef19c8206b")
   724  	assert.Equal(t, label.Key, "test-label")
   725  	assert.Equal(t, label.Color, "#00000")
   726  	assert.Equal(t, label.Visible, true)
   727  	assert.Equal(t, label.Editable, true)
   728  	assert.Equal(t, *label.BannerEdgeID, "f2af0c5b-7412-4f81-b024-1741e01700a3")
   729  	assert.Equal(t, label.Unique, true)
   730  	assert.Equal(t, label.Description, "test label")
   731  	assert.Equal(t, label.Type, "")
   732  }
   733  
   734  func TestGetLabelTenant(t *testing.T) {
   735  	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
   736  	if err != nil {
   737  		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
   738  	}
   739  	defer db.Close()
   740  
   741  	mock.ExpectQuery(sqlquery.GetTenantLabelQuery).
   742  		WillReturnRows(mock.NewRows([]string{"tenant_edge_id", "org_id", "org_name"}).
   743  			AddRow("de3bacfb-1600-4665-bcda-a6ef19c8206b", "3c81acabf8b34f91b811553f2a3ef912", "edge-dev0-edge-b413cb"))
   744  
   745  	artifactsService := artifacts.NewArtifactsService(db, nil)
   746  	service := NewLabelService(artifactsService, db)
   747  
   748  	tenant, err := service.GetLabelTenant(context.Background(), "de3bacfb-1600-4665-bcda-a6ef19c8206b")
   749  	assert.NoError(t, err)
   750  	assert.Equal(t, tenant.TenantEdgeID, "de3bacfb-1600-4665-bcda-a6ef19c8206b")
   751  	assert.Equal(t, tenant.TenantBSLId, "3c81acabf8b34f91b811553f2a3ef912")
   752  	assert.Equal(t, tenant.OrgName, "edge-dev0-edge-b413cb")
   753  }
   754
View as plain text