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

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