Update pandoc dockerfile and latex template and fix infinite build, fix pandoc always pull and fix strikethrough (#100, #103 and #115)

internal/model/fs.go

@@ -84,6 +84,10 @@ func ReadStandards() ([]*Standard, error) {
 		}
 
 		yaml.Unmarshal(sBytes, &s)
+		err = yaml.Unmarshal(sBytes, &s)
+		if err != nil {
+			return nil, errors.Wrap(err, "unable to parse "+f.FullPath)
+		}
 		standards = append(standards, s)
 	}
 
@@ -101,7 +105,10 @@ func ReadNarratives() ([]*Document, error) {
 
 	for _, f := range files {
 		n := &Document{}
-		mdmd := loadMDMD(f.FullPath)
+		mdmd, err := loadMDMD(f.FullPath)
+		if err != nil {
+			return nil, err
+		}
 		err = yaml.Unmarshal([]byte(mdmd.yaml), &n)
 		if err != nil {
 			return nil, errors.Wrap(err, "unable to parse "+f.FullPath)
@@ -126,7 +133,10 @@ func ReadProcedures() ([]*Procedure, error) {
 
 	for _, f := range files {
 		p := &Procedure{}
-		mdmd := loadMDMD(f.FullPath)
+		mdmd, err := loadMDMD(f.FullPath)
+		if err != nil {
+			return nil, err
+		}
 		err = yaml.Unmarshal([]byte(mdmd.yaml), &p)
 		if err != nil {
 			return nil, errors.Wrap(err, "unable to parse "+f.FullPath)
@@ -151,7 +161,10 @@ func ReadPolicies() ([]*Document, error) {
 
 	for _, f := range files {
 		p := &Document{}
-		mdmd := loadMDMD(f.FullPath)
+		mdmd, err := loadMDMD(f.FullPath)
+		if err != nil {
+			return nil, err
+		}
 		err = yaml.Unmarshal([]byte(mdmd.yaml), &p)
 		if err != nil {
 			return nil, errors.Wrap(err, "unable to parse "+f.FullPath)
@@ -171,21 +184,20 @@ type metadataMarkdown struct {
 	body string
 }
 
-func loadMDMD(path string) metadataMarkdown {
+func loadMDMD(path string) (*metadataMarkdown, error) {
 	bytes, err := ioutil.ReadFile(path)
 	if err != nil {
 		panic(err)
 	}
-
 	content := string(bytes)
 	components := strings.Split(content, "---")
 	if components[0] == "" && (len(components) > 1) {
 		components = components[1:]
 	}
 	if len(components) == 1 {
-		panic(fmt.Sprintf("Malformed metadata markdown in %s, must be of the form: YAML\\n---\\nmarkdown content", path))
+		return nil, errors.New(fmt.Sprintf("Malformed metadata markdown in %s, must be of the form: YAML\\n---\\nmarkdown content", path))
 	}
-	yaml := components[0]
+	item := components[0]
 	body := strings.Join(components[1:], "---")
-	return metadataMarkdown{yaml, body}
+	return &metadataMarkdown{item, body}, nil
 }

internal/model/fs_test.go

@@ -0,0 +1,238 @@
+package model
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/strongdm/comply/internal/path"
+	"github.com/strongdm/comply/internal/util"
+)
+
+type ReadFiles struct{}
+
+func beforeEach() {
+	util.MockConfig()
+}
+
+func TestReadFiles(t *testing.T) {
+	util.ExecuteTests(t, reflect.TypeOf(ReadFiles{}), beforeEach, nil)
+}
+
+// TestReadNarratives calls model.ReadNarratives checking for a valid return value.
+func (tg ReadFiles) TestReadNarratives(t *testing.T) {
+	filePath := fmt.Sprintf("%s/narratives/control.md", util.GetRootPath())
+	fileInfo, _ := os.Lstat(filePath)
+	path.Narratives = func() ([]path.File, error) {
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	documents, err := ReadNarratives()
+	if err != nil {
+		t.Fatalf(`ReadNarratives() returned an error %v`, err)
+	}
+	if len(documents) != 1 {
+		t.Fatal(`Invalid number of documents`)
+	}
+	if documents[0].FullPath != filePath {
+		t.Fatalf(`Invalid document path %s`, documents[0].FullPath)
+	}
+}
+
+// TestReadNarrativesWhenThereAreNoNarratives calls model.ReadNarratives checking for a valid return when
+// there are no narratives to process
+func (tg ReadFiles) TestReadNarrativesWhenThereAreNoNarratives(t *testing.T) {
+	path.Narratives = func() ([]path.File, error) {
+		return []path.File{}, nil
+	}
+
+	documents, err := ReadNarratives()
+	if err != nil {
+		t.Fatalf(`ReadNarratives() returned an error %v`, err)
+	}
+	if len(documents) != 0 {
+		t.Fatal(`Invalid number of documents`)
+	}
+}
+
+// TestReadNarrativesFailsWhenInvalidNarrative calls model.ReadNarratives checking for an error return when
+// there is an invalid narrative
+func (tg ReadFiles) TestReadNarrativesFailsWhenInvalidNarrative(t *testing.T) {
+	path.Narratives = func() ([]path.File, error) {
+		filePath := fmt.Sprintf("%s/../fixtures/narratives/invalid-control.md", util.GetRootPath())
+		fileInfo, _ := os.Lstat(filePath)
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	_, err := ReadNarratives()
+	if err == nil {
+		t.Fatal(`ReadNarratives() was expected to fail`)
+	}
+}
+
+// TestReadProcedures calls model.ReadProcedures checking for a valid return value.
+func (tg ReadFiles) TestReadProcedures(t *testing.T) {
+	filePath := fmt.Sprintf("%s/procedures/workstation.md", util.GetRootPath())
+	fileInfo, _ := os.Lstat(filePath)
+	path.Procedures = func() ([]path.File, error) {
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	documents, err := ReadProcedures()
+	if err != nil {
+		t.Fatalf(`ReadProcedures() returned an error %v`, err)
+	}
+	if len(documents) != 1 {
+		t.Fatal(`Invalid number of documents`)
+	}
+	if documents[0].FullPath != filePath {
+		t.Fatalf(`Invalid document path %s`, documents[0].FullPath)
+	}
+}
+
+// TestReadProceduresWhenThereAreNoProcedures calls model.ReadProcedures checking for a valid return when
+// there are no procedures to process
+func (tg ReadFiles) TestReadProceduresWhenThereAreNoProcedures(t *testing.T) {
+	path.Procedures = func() ([]path.File, error) {
+		return []path.File{}, nil
+	}
+
+	documents, err := ReadProcedures()
+	if err != nil {
+		t.Fatalf(`ReadProcedures() returned an error %v`, err)
+	}
+	if len(documents) != 0 {
+		t.Fatal(`Invalid number of documents`)
+	}
+}
+
+// TestReadProceduresFailsWhenInvalidProcedure calls model.ReadProcedures checking for an error return when
+// there is an invalid procedure
+func (tg ReadFiles) TestReadProceduresFailsWhenInvalidProcedure(t *testing.T) {
+	path.Procedures = func() ([]path.File, error) {
+		filePath := fmt.Sprintf("%s/../fixtures/procedures/invalid-workstation.md", util.GetRootPath())
+		fileInfo, _ := os.Lstat(filePath)
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	_, err := ReadProcedures()
+	if err == nil {
+		t.Fatal(`ReadProcedures() was expected to fail`, err)
+	}
+}
+
+// TestReadPolicies calls model.ReadPolicies checking for a valid return value.
+func (tg ReadFiles) TestReadPolicies(t *testing.T) {
+	filePath := fmt.Sprintf("%s/policies/access.md", util.GetRootPath())
+	fileInfo, _ := os.Lstat(filePath)
+	path.Policies = func() ([]path.File, error) {
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	documents, err := ReadPolicies()
+	if err != nil {
+		t.Fatalf(`ReadPolicies() returned an error %v`, err)
+	}
+	if len(documents) != 1 {
+		t.Fatal(`Invalid number of documents`)
+	}
+	if documents[0].FullPath != filePath {
+		t.Fatalf(`Invalid document path %s`, documents[0].FullPath)
+	}
+}
+
+// TestReadPoliciesWhenThereAreNoPolicies calls model.ReadPolicies checking for a valid return when
+// there are no policies to process
+func (tg ReadFiles) TestReadPoliciesWhenThereAreNoPolicies(t *testing.T) {
+	path.Policies = func() ([]path.File, error) {
+		return []path.File{}, nil
+	}
+
+	documents, err := ReadPolicies()
+	if err != nil {
+		t.Fatalf(`ReadPolicies() returned an error %v`, err)
+	}
+	if len(documents) != 0 {
+		t.Fatal(`Invalid number of documents`)
+	}
+}
+
+// TestReadPoliciesFailsWhenInvalidPolicy calls model.ReadPolicies checking for an error return when
+// there is an invalid policy
+func (tg ReadFiles) TestReadPoliciesFailsWhenInvalidPolicy(t *testing.T) {
+	path.Policies = func() ([]path.File, error) {
+		filePath := fmt.Sprintf("%s/../fixtures/policies/invalid-access.md", util.GetRootPath())
+		fileInfo, _ := os.Lstat(filePath)
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	_, err := ReadPolicies()
+	if err == nil {
+		t.Fatal(`ReadPolicies() was expected to fail`, err)
+	}
+}
+
+// TestReadStandards calls model.ReadStandards checking for a valid return value.
+func (tg ReadFiles) TestReadStandards(t *testing.T) {
+	filePath := fmt.Sprintf("%s/standards/TSC-2017.yml", util.GetRootPath())
+	fileInfo, _ := os.Lstat(filePath)
+	path.Standards = func() ([]path.File, error) {
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	documents, err := ReadStandards()
+	if err != nil {
+		t.Fatalf(`ReadStandards() returned an error %v`, err)
+	}
+	if len(documents) != 1 {
+		t.Fatal(`Invalid number of documents`)
+	}
+}
+
+// TestReadStandardsWhenThereAreNoStandards calls model.ReadStandards checking for a valid return when
+// there are no standards to process
+func (tg ReadFiles) TestReadStandardsWhenThereAreNoStandards(t *testing.T) {
+	path.Standards = func() ([]path.File, error) {
+		return []path.File{}, nil
+	}
+
+	documents, err := ReadStandards()
+	if err != nil {
+		t.Fatalf(`ReadStandards() returned an error %v`, err)
+	}
+	if len(documents) != 0 {
+		t.Fatal(`Invalid number of documents`)
+	}
+}
+
+// TestReadStandardsFailsWhenInvalidStandard calls model.ReadStandards checking for an error return when
+// there is an invalid standard
+func (tg ReadFiles) TestReadStandardsFailsWhenInvalidStandard(t *testing.T) {
+	path.Standards = func() ([]path.File, error) {
+		filePath := fmt.Sprintf("%s/../fixtures/standards/invalid-standard.yml", util.GetRootPath())
+		fileInfo, _ := os.Lstat(filePath)
+		return []path.File{
+			{FullPath: filePath, Info: fileInfo},
+		}, nil
+	}
+
+	_, err := ReadStandards()
+	if err == nil {
+		t.Fatal(`ReadStandards() was expected to fail`, err)
+	}
+}

internal/model/model_test.go

@@ -9,36 +9,32 @@ import (
 func TestMarshal(t *testing.T) {
 	d := Data{
 		Tickets: []*Ticket{
-			&Ticket{
+			{
 				ID: "t1",
 			},
 		},
 		Audits: []*Audit{
-			&Audit{
+			{
 				ID: "a1",
 			},
 		},
 		Procedures: []*Procedure{
-			&Procedure{
-				Code: "pro1",
+			{
+				ID: "pro1",
 			},
 		},
-		Policies: []*Policy{
-			&Policy{
+		Policies: []*Document{
+			{
 				Name: "pol1",
 			},
 		},
 	}
-
 	m, _ := json.Marshal(d)
-
 	encoded := string(m)
-
 	if !strings.Contains(encoded, "t1") ||
 		!strings.Contains(encoded, "a1") ||
 		!strings.Contains(encoded, "pro1") ||
 		!strings.Contains(encoded, "pol1") {
 		t.Error("identifier not found in marshalled string")
 	}
-
 }