func showRuleInfo(rule *rules.Rule) {
if rule.Desc == "" {
fmtc.Printf("\n {*}%s{!} {s}(Description is empty){!}\n", rule.FullName+".mock")
} else {
fmtc.Printf("\n {*}%s{!} - %s\n", rule.FullName+".mock", rule.Desc)
}
host := rule.Request.Host
if host == "" {
if knf.GetS(LISTING_HOST) != "" {
host = knf.GetS(LISTING_HOST)
} else {
host = ip
}
}
if knf.GetS(LISTING_SCHEME) != "" {
host = knf.GetS(LISTING_SCHEME) + "://" + host
}
if knf.GetS(LISTING_PORT) != "" {
host = host + ":" + knf.GetS(LISTING_PORT)
}
fmtc.Printf(" {s}%s %s%s{!}\n", rule.Request.Method, host, rule.Request.URL)
}
// Check check rule or all rules for some service
func Check(target string) error {
if target == "" {
return errors.New("You must difine mock file or service name")
}
targetService, targetMock, targetDir := rules.ParsePath(target)
serviceDir := path.Join(knf.GetS(DATA_RULE_DIR), targetService)
if !fsutil.IsExist(serviceDir) {
return fmtc.Errorf("Service %s is not exist", targetService)
}
var ruleInfoSlice []*RuleInfo
if targetMock != "" {
ruleInfoSlice = append(ruleInfoSlice, &RuleInfo{targetService, targetMock, targetDir})
} else {
mockFiles := fsutil.ListAllFiles(serviceDir, true,
&fsutil.ListingFilter{MatchPatterns: []string{"*.mock"}},
)
for _, mockFile := range mockFiles {
mockPath := path.Join(targetService, strings.Replace(mockFile, ".mock", "", -1))
_, targetMock, targetDir := rules.ParsePath(mockPath)
ruleInfoSlice = append(ruleInfoSlice, &RuleInfo{targetService, targetMock, targetDir})
}
}
if len(ruleInfoSlice) == 0 {
fmtc.Println("\n{y}No mock's were found{!}\n")
return nil
}
var maxProblemType = PROBLEM_NONE
for _, rule := range ruleInfoSlice {
maxProblemType = mathutil.MaxU8(checkRule(rule), maxProblemType)
}
if maxProblemType > PROBLEM_NONE {
fmtutil.Separator(false)
}
switch maxProblemType {
case PROBLEM_NONE:
fmtc.Printf("\n{g}%s{!}\n\n", okMessages[rand.Int(len(okMessages))])
case PROBLEM_WARN:
fmtc.Printf("{y}%s{!}\n\n", warnMessages[rand.Int(len(warnMessages))])
case PROBLEM_ERR:
fmtc.Printf("{r}%s{!}\n\n", errorMessages[rand.Int(len(errorMessages))])
}
return nil
}
// renderProblems print error and warn messages
func renderProblems(problems []*Problem) {
for _, problem := range problems {
switch problem.Type {
case PROBLEM_WARN:
fmtc.Printf("{y}WARNING →{!} {*}%s{!}\n\n", problem.Info)
case PROBLEM_ERR:
fmtc.Printf("{r}ERROR →{!} {*}%s{!}\n\n", problem.Info)
}
fmtc.Println(fmtutil.Wrap(problem.Desc, " ", 86))
fmtc.NewLine()
}
}
// renderLine render different type of source line
func renderLine(line string, dataType int) {
switch dataType {
case TYPE_EMPTY_LINE:
fmtc.NewLine()
case TYPE_SEPARATOR:
fmtc.Printf("{s}%s{!} %s {s}%s{!}\n", line[:3], line[3:22], line[22:])
case TYPE_HEADER:
fmtc.Printf("{s}%s{!}\n", line)
case TYPE_RECORD:
sepIndex := strings.Index(line, ":")
fmtc.Printf("{*}%s{!} %s\n", line[:sepIndex+1], line[sepIndex+1:])
}
}
func printError(message string) {
if arg.GetB(ARG_DAEMON) {
fmt.Printf("\n%s\n\n", message)
} else {
fmtc.Printf("\n{r}%s{!}\n\n", message)
}
}
func listService(observer *rules.Observer, service string) error {
rulesNames := observer.GetServiceRulesNames(service)
if len(rulesNames) == 0 {
return fmt.Errorf("Service %s is not found", service)
}
fmtc.Printf(
"\n{*r}%s{!} {s}(%s){!}\n", service,
pluralize.Pluralize(len(rulesNames), "mock", "mocks"),
)
for _, ruleName := range rulesNames {
rule := observer.GetRuleByName(service, ruleName)
if rule == nil {
continue
}
showRuleInfo(rule)
}
return nil
}
// printError print error message
func printError(f string, a ...interface{}) {
fmtc.Printf("{r}"+f+"{!}\n", a...)
}
