github.com/companieshouse/insolvency-api@v0.0.0-20231024103413-440c973d9e9b/service/soa_service_test.go (about)

     1  package service
     2  
     3  import (
     4  	"fmt"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/companieshouse/insolvency-api/mocks"
    11  	"github.com/companieshouse/insolvency-api/models"
    12  	"github.com/golang/mock/gomock"
    13  	"github.com/jarcoal/httpmock"
    14  	. "github.com/smartystreets/goconvey/convey"
    15  )
    16  
    17  func TestUnitIsValidStatementDate(t *testing.T) {
    18  	transactionID := "123"
    19  	apiURL := "https://api.companieshouse.gov.uk"
    20  
    21  	httpmock.Activate()
    22  	defer httpmock.DeactivateAndReset()
    23  
    24  	Convey("request supplied is invalid - no attachment has been supplied", t, func() {
    25  		mockCtrl := gomock.NewController(t)
    26  		defer mockCtrl.Finish()
    27  
    28  		defer httpmock.Reset()
    29  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
    30  
    31  		mockService := mocks.NewMockService(mockCtrl)
    32  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
    33  
    34  		statement := generateStatement()
    35  		statement.Attachments = []string{}
    36  
    37  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
    38  
    39  		So(validationErr, ShouldContainSubstring, "please supply at least one attachment")
    40  		So(err, ShouldBeNil)
    41  	})
    42  
    43  	Convey("request supplied is invalid - more than two attachments have been supplied", t, func() {
    44  		mockCtrl := gomock.NewController(t)
    45  		defer mockCtrl.Finish()
    46  
    47  		defer httpmock.Reset()
    48  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
    49  
    50  		mockService := mocks.NewMockService(mockCtrl)
    51  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
    52  
    53  		statement := generateStatement()
    54  		statement.Attachments = []string{
    55  			"1234567890",
    56  			"0987654321",
    57  			"2468097531",
    58  		}
    59  
    60  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
    61  
    62  		So(validationErr, ShouldContainSubstring, "please supply a maximum of two attachments")
    63  		So(err, ShouldBeNil)
    64  	})
    65  
    66  	Convey("valid request supplied - a minimum of one and a maximum of two attachments have been supplied", t, func() {
    67  		mockCtrl := gomock.NewController(t)
    68  		defer mockCtrl.Finish()
    69  
    70  		defer httpmock.Reset()
    71  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
    72  
    73  		statement := generateStatement()
    74  		i := 1
    75  		for i <= 2 {
    76  			mockService := mocks.NewMockService(mockCtrl)
    77  			mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
    78  
    79  			validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
    80  			So(validationErr, ShouldBeEmpty)
    81  			So(err, ShouldBeNil)
    82  			attachID := fmt.Sprintf("098765432%d", i)
    83  			statement.Attachments = append(statement.Attachments, attachID)
    84  			i = i + 1
    85  		}
    86  
    87  	})
    88  
    89  	Convey("error retrieving insolvency resource", t, func() {
    90  		mockCtrl := gomock.NewController(t)
    91  		defer mockCtrl.Finish()
    92  
    93  		mockService := mocks.NewMockService(mockCtrl)
    94  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(models.InsolvencyResourceDao{}, fmt.Errorf("err"))
    95  
    96  		statement := generateStatement()
    97  
    98  		req := httptest.NewRequest(http.MethodGet, "/", nil)
    99  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
   100  		So(err.Error(), ShouldContainSubstring, "err")
   101  		So(validationErr, ShouldBeEmpty)
   102  	})
   103  
   104  	Convey("error retrieving company details", t, func() {
   105  		mockCtrl := gomock.NewController(t)
   106  		defer mockCtrl.Finish()
   107  
   108  		defer httpmock.Reset()
   109  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusTeapot, ""))
   110  
   111  		mockService := mocks.NewMockService(mockCtrl)
   112  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
   113  
   114  		statement := generateStatement()
   115  		req := httptest.NewRequest(http.MethodGet, "/", nil)
   116  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
   117  		So(validationErr, ShouldBeEmpty)
   118  		So(err.Error(), ShouldContainSubstring, "error getting company details from DB")
   119  	})
   120  
   121  	Convey("error parsing appointedOn date", t, func() {
   122  		mockCtrl := gomock.NewController(t)
   123  		defer mockCtrl.Finish()
   124  
   125  		defer httpmock.Reset()
   126  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
   127  
   128  		mockService := mocks.NewMockService(mockCtrl)
   129  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
   130  
   131  		statement := generateStatement()
   132  		statement.StatementDate = "2001/1/2"
   133  
   134  		req := httptest.NewRequest(http.MethodGet, "/", nil)
   135  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
   136  		So(validationErr, ShouldBeEmpty)
   137  		So(err.Error(), ShouldContainSubstring, "error parsing date")
   138  	})
   139  
   140  	Convey("error parsing incorporatedOn date", t, func() {
   141  		mockCtrl := gomock.NewController(t)
   142  		defer mockCtrl.Finish()
   143  
   144  		defer httpmock.Reset()
   145  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("error")))
   146  
   147  		statement := generateStatement()
   148  		mockService := mocks.NewMockService(mockCtrl)
   149  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
   150  
   151  		req := httptest.NewRequest(http.MethodGet, "/", nil)
   152  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
   153  		So(validationErr, ShouldBeEmpty)
   154  		So(err.Error(), ShouldContainSubstring, "error parsing date")
   155  	})
   156  
   157  	Convey("invalid date - in the future", t, func() {
   158  		mockCtrl := gomock.NewController(t)
   159  		defer mockCtrl.Finish()
   160  
   161  		defer httpmock.Reset()
   162  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
   163  
   164  		mockService := mocks.NewMockService(mockCtrl)
   165  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
   166  
   167  		statement := generateStatement()
   168  		statement.StatementDate = time.Now().AddDate(0, 0, 1).Format("2006-01-02")
   169  
   170  		req := httptest.NewRequest(http.MethodGet, "/", nil)
   171  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
   172  		So(validationErr, ShouldContainSubstring, "should not be in the future")
   173  		So(err, ShouldBeNil)
   174  	})
   175  
   176  	Convey("invalid appointedOn date - before company was incorporated", t, func() {
   177  		mockCtrl := gomock.NewController(t)
   178  		defer mockCtrl.Finish()
   179  
   180  		defer httpmock.Reset()
   181  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
   182  
   183  		mockService := mocks.NewMockService(mockCtrl)
   184  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
   185  
   186  		statement := generateStatement()
   187  		statement.StatementDate = "1999-01-01"
   188  
   189  		req := httptest.NewRequest(http.MethodGet, "/", nil)
   190  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
   191  		So(validationErr, ShouldContainSubstring, "before the company was incorporated")
   192  		So(err, ShouldBeNil)
   193  	})
   194  
   195  	Convey("valid date", t, func() {
   196  		mockCtrl := gomock.NewController(t)
   197  		defer mockCtrl.Finish()
   198  
   199  		defer httpmock.Reset()
   200  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
   201  
   202  		mockService := mocks.NewMockService(mockCtrl)
   203  		mockService.EXPECT().GetInsolvencyResource(transactionID).Return(generateInsolvencyResource(), nil)
   204  
   205  		statement := generateStatement()
   206  
   207  		req := httptest.NewRequest(http.MethodGet, "/", nil)
   208  		validationErr, err := ValidateStatementDetails(mockService, &statement, transactionID, req)
   209  		So(validationErr, ShouldBeEmpty)
   210  		So(err, ShouldBeNil)
   211  	})
   212  
   213  	Convey("nil dao", t, func() {
   214  		mockCtrl := gomock.NewController(t)
   215  		defer mockCtrl.Finish()
   216  
   217  		defer httpmock.Reset()
   218  		httpmock.RegisterResponder(http.MethodGet, apiURL+"/company/1234", httpmock.NewStringResponder(http.StatusOK, companyProfileDateResponse("2000-06-26 00:00:00.000Z")))
   219  
   220  		mockService := mocks.NewMockService(mockCtrl)
   221  
   222  		req := httptest.NewRequest(http.MethodGet, "/", nil)
   223  		validationErr, err := ValidateStatementDetails(mockService, nil, transactionID, req)
   224  		So(validationErr, ShouldBeEmpty)
   225  		So(err.Error(), ShouldContainSubstring, "nil DAO passed to service for validation")
   226  	})
   227  
   228  }
   229  
   230  func generateStatement() models.StatementOfAffairsResourceDao {
   231  	return models.StatementOfAffairsResourceDao{
   232  		StatementDate: "2012-01-23",
   233  		Attachments: []string{
   234  			"123456789",
   235  		},
   236  	}
   237  }