SebastianCzoch/onesky-go

Assertions has 27 methods (exceeds 20 allowed). Consider refactoring.

Open

type Assertions struct {
    t TestingT
}

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
    if expected == nil || actual == nil ||
        reflect.TypeOf(actual).Kind() != reflect.Slice ||
        reflect.TypeOf(expected).Kind() != reflect.Slice {
        return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func InEpsilonSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
    if expected == nil || actual == nil ||
        reflect.TypeOf(actual).Kind() != reflect.Slice ||
        reflect.TypeOf(expected).Kind() != reflect.Slice {
        return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...)

• Read up
  Read up

File assertions.go has 535 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package assert

import (
    "bufio"
    "bytes"

Your code does not pass gofmt in 22 places. Go fmt your code!

Open

package assert

• Exclude checks
  • Disable engine
  • Disable check

Your code does not pass gofmt in 22 places. Go fmt your code!

Open

package assert

• Exclude checks
  • Disable engine
  • Disable check

Method Client.UploadFile has 10 return statements (exceeds 4 allowed).

Open

func (c *Client) UploadFile(file, fileFormat, locale string, keepStrings bool) (UploadData, error) {
    endpoint, err := getEndpoint("postFile")
    if err != nil {
        return UploadData{}, err
    }

Your code does not pass gofmt in 10 places. Go fmt your code!

Open

package assert

• Exclude checks
  • Disable engine
  • Disable check

Method Client.GetLanguages has 7 return statements (exceeds 4 allowed).

Open

func (c *Client) GetLanguages() ([]Language, error) {
    endpoint, err := getEndpoint("getLanguages")
    if err != nil {
        return nil, err
    }

Method Client.GetTranslationsStatus has 7 return statements (exceeds 4 allowed).

Open

func (c *Client) GetTranslationsStatus(fileName, locale string) (TranslationsStatus, error) {
    endpoint, err := getEndpoint("getTranslationsStatus")
    if err != nil {
        return TranslationsStatus{}, err
    }

Method Client.ImportTask has 7 return statements (exceeds 4 allowed).

Open

func (c *Client) ImportTask(importID int64) (TaskData, error) {
    endpoint, err := getEndpoint("importTask")
    if err != nil {
        return TaskData{}, err
    }

Method Client.ImportTasks has 7 return statements (exceeds 4 allowed).

Open

func (c *Client) ImportTasks(params map[string]interface{}) ([]TaskData, error) {
    endpoint, err := getEndpoint("importTasks")
    if err != nil {
        return nil, err
    }

Method Client.ListFiles has 7 return statements (exceeds 4 allowed).

Open

func (c *Client) ListFiles(page, perPage int) ([]FileData, error) {
    endpoint, err := getEndpoint("listFiles")
    if err != nil {
        return nil, err
    }

Method Client.DownloadFile has 6 return statements (exceeds 4 allowed).

Open

func (c *Client) DownloadFile(fileName, locale string) (string, error) {
    endpoint, err := getEndpoint("getFile")
    if err != nil {
        return "", err
    }

Function isEmpty has 6 return statements (exceeds 4 allowed).

Open

func isEmpty(object interface{}) bool {

    if object == nil {
        return true
    } else if object == "" {

Function HTTPBodyContains has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

func HTTPBodyContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {

Function HTTPBodyNotContains has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool {

Function InDelta has 5 return statements (exceeds 4 allowed).

Open

func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {

    af, aok := toFloat(expected)
    bf, bok := toFloat(actual)

Method Client.DeleteFile has 5 return statements (exceeds 4 allowed).

Open

func (c *Client) DeleteFile(fileName string) error {
    endpoint, err := getEndpoint("deleteFile")
    if err != nil {
        return err
    }

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func HTTPRedirect(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool {
    code := httpCode(handler, mode, url, values)
    if code == -1 {
        return false
    }

• Read up
  Read up