Entry("should return an error when it's unable to get remote components", getterErrors{
remoteComponentError: errors.New("Remote components error"),
expectedError: errors.New("Remote components error"),
}),
Entry("should return no error when able to get all components", getterErrors{
// everything is nil.
}),
)
Describe("GetLocalResources", func() {
DescribeTable("", func(recursively bool, initMap bool, resources []string, mkdirsError, copyError,
copyAllError, expectedError error) {
getter := vcsAndLocalFSGetter{}
getter.Parser = createMockParser(nil)
getter.FSUtil = createMockFSUtil(nil, nil, mkdirsError, copyError, copyAllError)
getter.ResourceMap = mapset.Init()
err := getter.GetLocalResources("", resources, "dest", "subfolder",
recursively, constants.Standards)
assert.Equal(GinkgoT(), expectedError, err)
},
Entry("Bad input to reserve", false, true, []string{""}, nil, nil, nil, mapset.ErrEmptyInput),
Entry("Successful recursive copy", true, true, []string{"res"}, nil, nil, nil, nil),
Entry("Successful single copy", false, true, []string{"res"}, nil, nil, nil, nil),
Entry("Failure of single copy", false, true, []string{"res"}, nil,
errors.New("single copy fail"), nil, errors.New("single copy fail")),
Entry("Mkdirs", false, true, []string{"res"},
errors.New("mkdirs error"), nil, nil, errors.New("mkdirs error")),
)
})
Describe("GetRemoteResources", func() {
)
var _ = Describe("ResourceGetter", func() {
Describe("GetLocalResources", func() {
var (
resMap mapset.MapSet
)
DescribeTable("", func(recursively bool, initMap bool, resources []string, mkdirsError, copyError, copyAllError, expectedError error) {
getter := VCSAndLocalFSGetter{}
fsUtil := new(fsmocks.Util)
fsUtil.On("Mkdirs", mock.AnythingOfType("string")).Return(mkdirsError)
fsUtil.On("Copy", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(copyError)
fsUtil.On("CopyAll", mock.AnythingOfType("string"), mock.AnythingOfType("string")).Return(copyAllError)
if initMap {
resMap = mapset.Init()
}
worker := new(common.ConfigWorker)
worker.ResourceMap = resMap
worker.FSUtil = fsUtil
err := getter.GetLocalResources("", resources, "dest", "subfolder", recursively, worker, constants.Standards)
assert.Equal(GinkgoT(), expectedError, err)
},
Entry("Bad input to reserve", false, true, []string{""}, nil, nil, nil, mapset.ErrEmptyInput),
Entry("Successful recursive copy", true, true, []string{"res"}, nil, nil, nil, nil),
Entry("Successful single copy", false, true, []string{"res"}, nil, nil, nil, nil),
Entry("Failure of single copy", false, true, []string{"res"}, nil, errors.New("single copy fail"), nil, errors.New("single copy fail")),
Entry("Mkdirs", false, true, []string{"res"}, errors.New("mkdirs error"), nil, nil, errors.New("mkdirs error")),
)
})
Describe("GetRemoteResources", func() {
// NewCLIApp creates a new instances of the CLI
func NewCLIApp() *cli.App {
app := cli.NewApp()
app.Name = "Compliance Masonry"
app.Usage = "Open Control CLI Tool"
app.Version = "1.1.1"
app.Flags = []cli.Flag{
cli.BoolFlag{
Name: "verbose",
Usage: "Indicates whether to run the command with verbosity.",
},
}
app.Before = func(c *cli.Context) error {
// Resets the log to output to nothing
log.SetOutput(ioutil.Discard)
if c.Bool("verbose") {
log.SetOutput(os.Stderr)
log.Println("Running with verbosity")
}
return nil
}
app.Commands = []cli.Command{
{
Name: "get",
Aliases: []string{"g"},
Usage: "Install compliance dependencies",
Flags: []cli.Flag{
cli.StringFlag{
Name: "dest",
Value: constants.DefaultDestination,
Usage: "Location to download the repos.",
},
cli.StringFlag{
Name: "config",
Value: constants.DefaultConfigYaml,
Usage: "Location of system yaml",
},
},
Action: func(c *cli.Context) error {
f := fs.OSUtil{}
config := c.String("config")
configBytes, err := f.OpenAndReadFile(config)
if err != nil {
app.Writer.Write([]byte(err.Error()))
os.Exit(1)
}
wd, err := os.Getwd()
if err != nil {
app.Writer.Write([]byte(err.Error()))
os.Exit(1)
}
destination := filepath.Join(wd, c.String("dest"))
err = Get(destination,
configBytes,
&common.ConfigWorker{Downloader: common.NewVCSDownloader(), Parser: parser.Parser{}, ResourceMap: mapset.Init(), FSUtil: f})
if err != nil {
return cli.NewExitError(err.Error(), 1)
}
app.Writer.Write([]byte("Compliance Dependencies Installed"))
return nil
},
},
{
Name: "docs",
Aliases: []string{"d"},
Usage: "Create Documentation",
Subcommands: []cli.Command{
{
Name: "gitbook",
Aliases: []string{"g"},
Usage: "Create Gitbook Documentation",
Flags: []cli.Flag{
cli.StringFlag{
Name: "opencontrols, o",
Value: "opencontrols",
Usage: "Set opencontrols directory",
Destination: &opencontrolDir,
},
cli.StringFlag{
Name: "exports, e",
Value: "exports",
Usage: "Sets the export directory",
Destination: &exportPath,
},
cli.StringFlag{
Name: "markdowns, m",
Value: "markdowns",
Usage: "Sets the markdowns directory",
Destination: &markdownPath,
},
},
Action: func(c *cli.Context) error {
config := gitbook.Config{
Certification: c.Args().First(),
OpencontrolDir: opencontrolDir,
ExportPath: exportPath,
MarkdownPath: markdownPath,
}
warning, errMessages := docs.MakeGitbook(config)
if warning != "" {
app.Writer.Write([]byte(warning))
}
if errMessages != nil && len(errMessages) > 0 {
err := cli.NewMultiError(errMessages...)
return cli.NewExitError(err.Error(), 1)
} else {
app.Writer.Write([]byte("New Gitbook Documentation Created"))
return nil
}
},
},
{
Name: "docx",
Aliases: []string{"d"},
Usage: "Create Docx Documentation using a Template",
Flags: []cli.Flag{
cli.StringFlag{
Name: "opencontrols, o",
Value: "opencontrols",
Usage: "Set opencontrols directory",
Destination: &opencontrolDir,
},
cli.StringFlag{
Name: "template, t",
Value: "",
Usage: "Set template to build",
Destination: &templatePath,
},
cli.StringFlag{
Name: "export, e",
Value: "export.docx",
Usage: "Sets the export directory",
Destination: &exportPath,
},
},
Action: func(c *cli.Context) error {
config := docx.Config{
OpencontrolDir: opencontrolDir,
TemplatePath: templatePath,
ExportPath: exportPath,
}
if err := docs.BuildTemplate(config); err != nil && len(err.Error()) > 0 {
return cli.NewExitError(err.Error(), 1)
} else {
app.Writer.Write([]byte("New Docx Created"))
return nil
}
},
},
},
},
diffCommand,
}
return app
}
// NewVCSAndLocalGetter constructs a new resource getter with the type of parser to use for the files.
func NewVCSAndLocalGetter(parser opencontrol.SchemaParser) Getter {
return &vcsAndLocalFSGetter{Downloader: NewVCSDownloader(), FSUtil: fs.OSUtil{}, Parser: parser,
ResourceMap: mapset.Init()}
}
