update vendor/github.com/DreamItGetIT/statuscake/ to manage ssl tests

23 files changed, 1854 insertions, 2 deletions

diff --git a/vendor/github.com/DreamItGetIT/statuscake/Gopkg.lock b/vendor/github.com/DreamItGetIT/statuscake/Gopkg.lock
index c5b189e..b433daf 100644
--- a/vendor/github.com/DreamItGetIT/statuscake/Gopkg.lock
+++ b/vendor/github.com/DreamItGetIT/statuscake/Gopkg.lock
@@ -18,6 +18,14 @@
   version = "v1.1.1"
 
 [[projects]]
+  digest = "1:a63cff6b5d8b95638bfe300385d93b2a6d9d687734b863da8e09dc834510a690"
+  name = "github.com/google/go-querystring"
+  packages = ["query"]
+  pruneopts = "UT"
+  revision = "44c6ddd0a2342c386950e880b658017258da92fc"
+  version = "v1.0.0"
+
+[[projects]]
   digest = "1:0028cb19b2e4c3112225cd871870f2d9cf49b9b4276531f03438a88e94be86fe"
   name = "github.com/pmezard/go-difflib"
   packages = ["difflib"]
@@ -30,7 +38,7 @@
   name = "github.com/stretchr/testify"
   packages = [
     "assert",
-    "require",
+    "require"
   ]
   pruneopts = "UT"
   revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686"
@@ -41,8 +49,9 @@
   analyzer-version = 1
   input-imports = [
     "github.com/DreamItGetIT/statuscake",
+    "github.com/google/go-querystring/query",
     "github.com/stretchr/testify/assert",
-    "github.com/stretchr/testify/require",
+    "github.com/stretchr/testify/require"
   ]
   solver-name = "gps-cdcl"
   solver-version = 1
diff --git a/vendor/github.com/DreamItGetIT/statuscake/Gopkg.toml b/vendor/github.com/DreamItGetIT/statuscake/Gopkg.toml
index b0c1687..e02ee65 100644
--- a/vendor/github.com/DreamItGetIT/statuscake/Gopkg.toml
+++ b/vendor/github.com/DreamItGetIT/statuscake/Gopkg.toml
@@ -36,3 +36,7 @@
 [prune]
   go-tests = true
   unused-packages = true
+
+[[constraint]]
+  name = "github.com/google/go-querystring"
+  version = "1.0.0"
diff --git a/vendor/github.com/DreamItGetIT/statuscake/client_test.go b/vendor/github.com/DreamItGetIT/statuscake/client_test.go
new file mode 100644
index 0000000..7c40c81
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/client_test.go
@@ -0,0 +1,236 @@
+package statuscake
+
+import (
+        "bytes"
+        "io"
+        "io/ioutil"
+        "log"
+        "net/http"
+        "net/url"
+        "os"
+        "path/filepath"
+        "testing"
+
+        "github.com/stretchr/testify/assert"
+        "github.com/stretchr/testify/require"
+)
+
+func TestAuth_validate(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        auth := &Auth{}
+        err := auth.validate()
+
+        require.NotNil(err)
+        assert.Contains(err.Error(), "Username is required")
+        assert.Contains(err.Error(), "Apikey is required")
+
+        auth.Username = "foo"
+        err = auth.validate()
+
+        require.NotNil(err)
+        assert.Equal("Apikey is required", err.Error())
+
+        auth.Apikey = "bar"
+        err = auth.validate()
+        assert.Nil(err)
+}
+
+func TestClient(t *testing.T) {
+        require := require.New(t)
+        assert := assert.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        assert.Equal("random-user", c.username)
+        assert.Equal("my-pass", c.apiKey)
+}
+
+func TestClient_newRequest(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        r, err := c.newRequest("GET", "/hello", nil, nil)
+
+        require.Nil(err)
+        assert.Equal("GET", r.Method)
+        assert.Equal("https://app.statuscake.com/API/hello", r.URL.String())
+        assert.Equal("random-user", r.Header.Get("Username"))
+        assert.Equal("my-pass", r.Header.Get("API"))
+}
+
+func TestClient_doRequest(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        hc := &fakeHTTPClient{StatusCode: 200}
+        c.c = hc
+
+        req, err := http.NewRequest("GET", "http://example.com/test", nil)
+        require.Nil(err)
+
+        _, err = c.doRequest(req)
+        require.Nil(err)
+
+        assert.Len(hc.requests, 1)
+        assert.Equal("http://example.com/test", hc.requests[0].URL.String())
+}
+
+func TestClient_doRequest_WithHTTPErrors(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        hc := &fakeHTTPClient{
+                StatusCode: 500,
+        }
+        c.c = hc
+
+        req, err := http.NewRequest("GET", "http://example.com/test", nil)
+        require.Nil(err)
+
+        _, err = c.doRequest(req)
+        require.NotNil(err)
+        assert.IsType(&httpError{}, err)
+}
+
+func TestClient_doRequest_HttpAuthenticationErrors(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        hc := &fakeHTTPClient{
+                StatusCode: 200,
+                Fixture:    "auth_error.json",
+        }
+        c.c = hc
+
+        req, err := http.NewRequest("GET", "http://example.com/test", nil)
+        require.Nil(err)
+
+        _, err = c.doRequest(req)
+        require.NotNil(err)
+        assert.IsType(&AuthenticationError{}, err)
+}
+
+func TestClient_get(t *testing.T) {
+        require := require.New(t)
+        assert := assert.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        hc := &fakeHTTPClient{}
+        c.c = hc
+
+        c.get("/hello", nil)
+        assert.Len(hc.requests, 1)
+        assert.Equal("GET", hc.requests[0].Method)
+        assert.Equal("https://app.statuscake.com/API/hello", hc.requests[0].URL.String())
+}
+
+func TestClient_put(t *testing.T) {
+        require := require.New(t)
+        assert := assert.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        hc := &fakeHTTPClient{}
+        c.c = hc
+
+        v := url.Values{"foo": {"bar"}}
+        c.put("/hello", v)
+        assert.Len(hc.requests, 1)
+        assert.Equal("PUT", hc.requests[0].Method)
+        assert.Equal("https://app.statuscake.com/API/hello", hc.requests[0].URL.String())
+
+        b, err := ioutil.ReadAll(hc.requests[0].Body)
+        require.Nil(err)
+        assert.Equal("foo=bar", string(b))
+}
+
+func TestClient_delete(t *testing.T) {
+        require := require.New(t)
+        assert := assert.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        hc := &fakeHTTPClient{}
+        c.c = hc
+
+        v := url.Values{"foo": {"bar"}}
+        c.delete("/hello", v)
+        assert.Len(hc.requests, 1)
+        assert.Equal("DELETE", hc.requests[0].Method)
+        assert.Equal("https://app.statuscake.com/API/hello?foo=bar", hc.requests[0].URL.String())
+}
+
+func TestClient_Tests(t *testing.T) {
+        require := require.New(t)
+        assert := assert.New(t)
+
+        c, err := New(Auth{Username: "random-user", Apikey: "my-pass"})
+        require.Nil(err)
+
+        expected := &tests{
+                client: c,
+        }
+
+        assert.Equal(expected, c.Tests())
+}
+
+type fakeBody struct {
+        io.Reader
+}
+
+func (f *fakeBody) Close() error {
+        return nil
+}
+
+type fakeHTTPClient struct {
+        StatusCode int
+        Fixture    string
+        requests   []*http.Request
+}
+
+func (c *fakeHTTPClient) Do(r *http.Request) (*http.Response, error) {
+        c.requests = append(c.requests, r)
+        var body []byte
+
+        if c.Fixture != "" {
+                p := filepath.Join("fixtures", c.Fixture)
+                f, err := os.Open(p)
+                if err != nil {
+                        log.Fatal(err)
+                }
+                defer f.Close()
+
+                b, err := ioutil.ReadAll(f)
+                if err != nil {
+                        log.Fatal(err)
+                }
+
+                body = b
+        }
+
+        resp := &http.Response{
+                StatusCode: c.StatusCode,
+                Body:       &fakeBody{Reader: bytes.NewReader(body)},
+        }
+
+        return resp, nil
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/cmd/statuscake/main.go b/vendor/github.com/DreamItGetIT/statuscake/cmd/statuscake/main.go
new file mode 100644
index 0000000..59f41a9
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/cmd/statuscake/main.go
@@ -0,0 +1,246 @@
+package main
+
+import (
+        "fmt"
+        logpkg "log"
+        "os"
+        "strconv"
+
+        "github.com/DreamItGetIT/statuscake"
+        "strings"
+)
+
+var log *logpkg.Logger
+
+type command func(*statuscake.Client, ...string) error
+
+var commands map[string]command
+
+func init() {
+        log = logpkg.New(os.Stderr, "", 0)
+        commands = map[string]command{
+                "list":   cmdList,
+                "detail": cmdDetail,
+                "delete": cmdDelete,
+                "create": cmdCreate,
+                "update": cmdUpdate,
+        }
+}
+
+func colouredStatus(s string) string {
+        switch s {
+        case "Up":
+                return fmt.Sprintf("\033[0;32m%s\033[0m", s)
+        case "Down":
+                return fmt.Sprintf("\033[0;31m%s\033[0m", s)
+        default:
+                return s
+        }
+}
+
+func getEnv(name string) string {
+        v := os.Getenv(name)
+        if v == "" {
+                log.Fatalf("`%s` env variable is required", name)
+        }
+
+        return v
+}
+
+func cmdList(c *statuscake.Client, args ...string) error {
+        tt := c.Tests()
+        tests, err := tt.All()
+        if err != nil {
+                return err
+        }
+
+        for _, t := range tests {
+                var paused string
+                if t.Paused {
+                        paused = "yes"
+                } else {
+                        paused = "no"
+                }
+
+                fmt.Printf("* %d: %s\n", t.TestID, colouredStatus(t.Status))
+                fmt.Printf("  WebsiteName: %s\n", t.WebsiteName)
+                fmt.Printf("  TestType: %s\n", t.TestType)
+                fmt.Printf("  Paused: %s\n", paused)
+                fmt.Printf("  ContactGroup: %s\n", fmt.Sprint(t.ContactGroup))
+                fmt.Printf("  Uptime: %f\n", t.Uptime)
+        }
+
+        return nil
+}
+
+func cmdDetail(c *statuscake.Client, args ...string) error {
+        if len(args) != 1 {
+                return fmt.Errorf("command `detail` requires a single argument `TestID`")
+        }
+
+        id, err := strconv.Atoi(args[0])
+        if err != nil {
+                return err
+        }
+
+        tt := c.Tests()
+        t, err := tt.Detail(id)
+        if err != nil {
+                return err
+        }
+
+        var paused string
+        if t.Paused {
+                paused = "yes"
+        } else {
+                paused = "no"
+        }
+
+        fmt.Printf("* %d: %s\n", t.TestID, colouredStatus(t.Status))
+        fmt.Printf("  WebsiteName: %s\n", t.WebsiteName)
+        fmt.Printf("  WebsiteURL: %s\n", t.WebsiteURL)
+        fmt.Printf("  PingURL: %s\n", t.PingURL)
+        fmt.Printf("  TestType: %s\n", t.TestType)
+        fmt.Printf("  Paused: %s\n", paused)
+        fmt.Printf("  ContactGroup: %s\n", fmt.Sprint(t.ContactGroup))
+        fmt.Printf("  Uptime: %f\n", t.Uptime)
+        fmt.Printf("  NodeLocations: %s\n", fmt.Sprint(t.NodeLocations))
+
+        return nil
+}
+
+func cmdDelete(c *statuscake.Client, args ...string) error {
+        if len(args) != 1 {
+                return fmt.Errorf("command `delete` requires a single argument `TestID`")
+        }
+
+        id, err := strconv.Atoi(args[0])
+        if err != nil {
+                return err
+        }
+
+        return c.Tests().Delete(id)
+}
+
+func askString(name string) string {
+        var v string
+
+        fmt.Printf("%s: ", name)
+        _, err := fmt.Scanln(&v)
+        if err != nil {
+                log.Fatal(err)
+        }
+
+        return v
+}
+
+func askInt(name string) int {
+        v := askString(name)
+        i, err := strconv.Atoi(v)
+        if err != nil {
+                log.Fatalf("Invalid number `%s`", v)
+        }
+
+        return i
+}
+
+func cmdCreate(c *statuscake.Client, args ...string) error {
+        websiteName := askString("WebsiteName")
+        websiteURL := askString("WebsiteURL")
+        testType := askString("TestType")
+        checkRate := askInt("CheckRate")
+        contactGroupString := askString("ContactGroup (comma separated list)")
+        contactGroup := strings.Split(contactGroupString, ",")
+        nodeLocationsString := askString("NodeLocations (comma separated list)")
+        nodeLocations := strings.Split(nodeLocationsString, ",")
+
+        t := &statuscake.Test{
+                WebsiteName:   websiteName,
+                WebsiteURL:    websiteURL,
+                TestType:      testType,
+                CheckRate:     checkRate,
+                NodeLocations: nodeLocations,
+                ContactGroup:  contactGroup,
+        }
+
+        t2, err := c.Tests().Update(t)
+        if err != nil {
+                return err
+        }
+
+        fmt.Printf("CREATED: \n%+v\n", t2)
+
+        return nil
+}
+
+func cmdUpdate(c *statuscake.Client, args ...string) error {
+        if len(args) != 1 {
+                return fmt.Errorf("command `update` requires a single argument `TestID`")
+        }
+
+        id, err := strconv.Atoi(args[0])
+        if err != nil {
+                return err
+        }
+
+        tt := c.Tests()
+        t, err := tt.Detail(id)
+        if err != nil {
+                return err
+        }
+
+        t.TestID = id
+        t.WebsiteName = askString(fmt.Sprintf("WebsiteName [%s]", t.WebsiteName))
+        t.WebsiteURL = askString(fmt.Sprintf("WebsiteURL [%s]", t.WebsiteURL))
+        t.TestType = askString(fmt.Sprintf("TestType [%s]", t.TestType))
+        t.CheckRate = askInt(fmt.Sprintf("CheckRate [%d]", t.CheckRate))
+        contactGroupString := askString("ContactGroup (comma separated list)")
+        t.ContactGroup = strings.Split(contactGroupString, ",")
+        nodeLocationsString := askString("NodeLocations (comma separated list)")
+        t.NodeLocations = strings.Split(nodeLocationsString, ",")
+
+        t2, err := c.Tests().Update(t)
+        if err != nil {
+                return err
+        }
+
+        fmt.Printf("UPDATED: \n%+v\n", t2)
+
+        return nil
+}
+
+func usage() {
+        fmt.Printf("Usage:\n")
+        fmt.Printf("  %s COMMAND\n", os.Args[0])
+        fmt.Printf("Available commands:\n")
+        for k := range commands {
+                fmt.Printf("  %+v\n", k)
+        }
+}
+
+func main() {
+        username := getEnv("STATUSCAKE_USERNAME")
+        apikey := getEnv("STATUSCAKE_APIKEY")
+
+        if len(os.Args) < 2 {
+                usage()
+                os.Exit(1)
+        }
+
+        var err error
+
+        c, err := statuscake.New(statuscake.Auth{Username: username, Apikey: apikey})
+        if err != nil {
+                log.Fatal(err)
+        }
+
+        if cmd, ok := commands[os.Args[1]]; ok {
+                err = cmd(c, os.Args[2:]...)
+        } else {
+                err = fmt.Errorf("Unknown command `%s`", os.Args[1])
+        }
+
+        if err != nil {
+                log.Fatalf("Error running command `%s`: %s", os.Args[1], err.Error())
+        }
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/auth_error.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/auth_error.json
new file mode 100644
index 0000000..4f14be5
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/auth_error.json
@@ -0,0 +1,4 @@
+{
+  "ErrNo": 0,
+  "Error": "Can not access account. Was both Username and API Key provided?"
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslCreateOk.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslCreateOk.json
new file mode 100644
index 0000000..615e2db
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslCreateOk.json
@@ -0,0 +1,14 @@
+{
+  "Success": true,
+  "Message": 143616,
+  "Input": {
+    "domain": "https://www.exemple.com",
+    "checkrate": "2073600",
+    "contact_groups": "",
+    "alert_reminder": true,
+    "alert_expiry": true,
+    "alert_broken": true,
+    "alert_mixed": true,
+    "alert_at": "7,18,2019"
+  }
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslDeleteOk.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslDeleteOk.json
new file mode 100644
index 0000000..a394239
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslDeleteOk.json
@@ -0,0 +1,4 @@
+{
+  "Success": true,
+  "Message": "Deletion successful"
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslListAllOk.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslListAllOk.json
new file mode 100644
index 0000000..15c428f
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslListAllOk.json
@@ -0,0 +1,100 @@
+[
+    {
+        "id": "143615",
+        "checkrate": 2073600,
+        "paused": false,
+        "domain": "https://www.exemple.com",
+        "issuer_cn": "Let's Encrypt Authority X3",
+        "cert_score": "95",
+        "cipher_score": "100",
+        "cert_status": "CERT_OK",
+        "cipher": "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+        "valid_from_utc": "2019-05-28 01:22:00",
+        "valid_until_utc": "2019-08-26 01:22:00",
+        "mixed_content": [],
+        "flags": {
+            "is_extended": false,
+            "has_pfs": true,
+            "is_broken": false,
+            "is_expired": false,
+            "is_missing": false,
+            "is_revoked": false,
+            "has_mixed": false
+        },
+        "contact_groups": [],
+        "alert_at": "7,18,2019",
+        "last_reminder": 2019,
+        "alert_reminder": true,
+        "alert_expiry": true,
+        "alert_broken": true,
+        "alert_mixed": true,
+        "last_updated_utc": "2019-06-20 10:11:03"
+    },
+    {
+        "id": "143616",
+        "checkrate": 2073600,
+        "paused": false,
+        "domain": "https://www.exemple.com",
+        "issuer_cn": "Let's Encrypt Authority X3",
+        "cert_score": "95",
+        "cipher_score": "100",
+        "cert_status": "CERT_OK",
+        "cipher": "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+        "valid_from_utc": "2019-05-28 01:22:00",
+        "valid_until_utc": "2019-08-26 01:22:00",
+        "mixed_content": [
+            {
+                "type": "img",
+                "src": "http://example.com/image.gif"
+            }
+        ],
+        "flags": {
+            "is_extended": false,
+            "has_pfs": true,
+            "is_broken": false,
+            "is_expired": false,
+            "is_missing": false,
+            "is_revoked": false,
+            "has_mixed": false
+        },
+        "contact_groups": ["12","13","34"],
+        "alert_at": "7,18,2019",
+        "last_reminder": 2019,
+        "alert_reminder": true,
+        "alert_expiry": true,
+        "alert_broken": true,
+        "alert_mixed": true,
+        "last_updated_utc": "2019-06-20 10:23:14"
+    },
+    {
+        "id": "143617",
+        "checkrate": 2073600,
+        "paused": false,
+        "domain": "https://www.exemple.com",
+        "issuer_cn": "Let's Encrypt Authority X3",
+        "cert_score": "95",
+        "cipher_score": "100",
+        "cert_status": "CERT_OK",
+        "cipher": "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+        "valid_from_utc": "2019-05-28 01:22:00",
+        "valid_until_utc": "2019-08-26 01:22:00",
+        "mixed_content": [],
+        "flags": {
+            "is_extended": false,
+            "has_pfs": true,
+            "is_broken": false,
+            "is_expired": false,
+            "is_missing": false,
+            "is_revoked": false,
+            "has_mixed": false
+        },
+        "contact_groups": [],
+        "alert_at": "7,18,2019",
+        "last_reminder": 2019,
+        "alert_reminder": true,
+        "alert_expiry": true,
+        "alert_broken": true,
+        "alert_mixed": true,
+        "last_updated_utc": "2019-06-20 10:23:20"
+    }
+]
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslUpdateOk.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslUpdateOk.json
new file mode 100644
index 0000000..23b5932
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/sslUpdateOk.json
@@ -0,0 +1,4 @@
+{
+  "Success": true,
+  "Message": "SSL test has been updated successfully"
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_all_ok.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_all_ok.json
new file mode 100644
index 0000000..4dd6b51
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_all_ok.json
@@ -0,0 +1,70 @@
+[
+  {
+    "id": "12345",
+    "paused": false,
+    "domain": "https://google.com",
+    "cert_score": "95",
+    "cipher_score": "100",
+    "cert_status": "CERT_OK",
+    "cipher": "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+    "valid_from_utc": "2017-10-10 14:06:00",
+    "valid_until_utc": "2017-12-29 00:00:00",
+    "mixed_content": [
+      {
+        "type": "img",
+        "src": "http://example.com/image.gif"
+      }
+    ],
+    "flags": {
+      "is_extended": false,
+      "has_pfs": true,
+      "is_broken": false,
+      "is_expired": false,
+      "is_missing": false,
+      "is_revoked": false,
+      "is_mixed": false
+    },
+    "contact_groups": [12, 13, 14],
+    "alert_at": "1,7,30",
+    "last_reminder": 0,
+    "alert_reminder": false,
+    "alert_expiry": false,
+    "alert_broken": false,
+    "alert_mixed": false,
+    "last_updated_utc": "2017-10-24 09:02:25"
+  },
+  {
+    "id": "12346",
+    "paused": false,
+    "domain": "https://google2.com",
+    "cert_score": "95",
+    "cipher_score": "100",
+    "cert_status": "CERT_OK",
+    "cipher": "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+    "valid_from_utc": "2017-10-10 14:06:00",
+    "valid_until_utc": "2017-12-29 00:00:00",
+    "mixed_content": [
+      {
+        "type": "img",
+        "src": "http://example.com/image.gif"
+      }
+    ],
+    "flags": {
+      "is_extended": false,
+      "has_pfs": true,
+      "is_broken": false,
+      "is_expired": false,
+      "is_missing": false,
+      "is_revoked": false,
+      "is_mixed": false
+    },
+    "contact_groups": [12, 13, 14],
+    "alert_at": "1,7,30",
+    "last_reminder": 0,
+    "alert_reminder": false,
+    "alert_expiry": false,
+    "alert_broken": false,
+    "alert_mixed": false,
+    "last_updated_utc": "2017-10-24 09:02:25"
+  }
+]
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_create_ok.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_create_ok.json
new file mode 100644
index 0000000..c7734e0
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_create_ok.json
@@ -0,0 +1,13 @@
+{
+  "Success": true,
+  "Message": 12345,
+  "Input": {
+    "domain": "https://example.com",
+    "checkrate": 86400,
+    "contact_groups": "1000,2000",
+    "alert_reminder": false,
+    "alert_expiry": false,
+    "alert_broken": false,
+    "alert_at": "59,60,61"
+  }
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_update_error.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_update_error.json
new file mode 100644
index 0000000..5f0f4d5
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_update_error.json
@@ -0,0 +1,13 @@
+{
+  "Success": false,
+  "Message": "Error creating test",
+  "Input": {
+    "domain": "https://example.com",
+    "checkrate": 86400,
+    "contact_groups": "1000,2000",
+    "alert_reminder": false,
+    "alert_expiry": false,
+    "alert_broken": false,
+    "alert_at": "59,60,61"
+  }
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_update_ok.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_update_ok.json
new file mode 100644
index 0000000..f77f4f3
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/ssls_update_ok.json
@@ -0,0 +1,4 @@
+{
+    "Success": true,
+    "Message": "SSL test has been updated successfully"
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_all_ok.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_all_ok.json
new file mode 100644
index 0000000..dee80d4
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_all_ok.json
@@ -0,0 +1,23 @@
+[
+  {
+      "TestID": 100,
+      "Paused": false,
+      "TestType": "HTTP",
+      "WebsiteName": "www 1",
+      "ContactGroup": ["1"],
+      "Status": "Up",
+      "Uptime": 100,
+      "NodeLocations": ["foo", "bar"]
+  },
+  {
+      "TestID": 101,
+      "Paused": true,
+      "TestType": "HTTP",
+      "WebsiteName": "www 2",
+      "ContactGroup": ["2"],
+      "Status": "Down",
+      "Uptime": 0,
+      "NodeLocations": ["foo"],
+      "TestTags": ["test1", "test2"]
+  }
+]
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_delete_error.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_delete_error.json
new file mode 100644
index 0000000..6fad58e
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_delete_error.json
@@ -0,0 +1,5 @@
+{
+  "Success": false,
+  "Error": "this is an error"
+}
+
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_delete_ok.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_delete_ok.json
new file mode 100644
index 0000000..0dd279b
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_delete_ok.json
@@ -0,0 +1,6 @@
+{
+  "TestID": 6735,
+  "Affected": 1,
+  "Success": true,
+  "Message": "This Check Has Been Deleted. It can not be recovered."
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_detail_ok.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_detail_ok.json
new file mode 100644
index 0000000..a64989b
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_detail_ok.json
@@ -0,0 +1,39 @@
+{
+  "TestID": 6735,
+  "TestType": "HTTP",
+  "Paused": false,
+  "WebsiteName": "NL",
+  "CustomHeader": "{\"some\":{\"json\": [\"value\"]}}",
+  "UserAgent": "product/version (comment)",
+  "ContactGroups": [
+    {
+    "ID": 536,
+    "Name": "Dummy ContactGroup",
+    "Email": "github-dreamitgetit-statuscake@maildrop.cc"
+    }
+  ],
+  "ContactID": 536,
+  "Status": "Up",
+  "Uptime": 0,
+  "CheckRate": 60,
+  "Timeout": 40,
+  "LogoImage": "",
+  "WebsiteHost": "Various",
+  "NodeLocations": [
+    "foo",
+    "bar"
+  ],
+  "FindString": "",
+  "DoNotFind": false,
+  "LastTested": "2013-01-20 14:38:18",
+  "NextLocation": "USNY",
+  "Processing": false,
+  "ProcessingState": "Pretest",
+  "ProcessingOn": "dalas.localdomain",
+  "DownTimes": "0",
+  "UseJar": 0,
+  "PostRaw": "",
+  "FinalEndpoint": "",
+  "EnableSSLWarning": false,
+  "FollowRedirect": false
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_error.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_error.json
new file mode 100644
index 0000000..a76c5eb
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_error.json
@@ -0,0 +1,9 @@
+{
+  "Issues": {
+    "WebsiteName": "issue a",
+    "WebsiteURL": "issue b",
+    "CheckRate": "issue c"
+  },
+  "Success": false,
+  "Message": "Required Data is Missing."
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_error_slice_of_issues.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_error_slice_of_issues.json
new file mode 100644
index 0000000..02e98eb
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_error_slice_of_issues.json
@@ -0,0 +1,5 @@
+{
+  "Issues": ["hello", "world"],
+  "Success": false,
+  "Message": "Required Data is Missing."
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_ok.json b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_ok.json
new file mode 100644
index 0000000..7c2dee2
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/fixtures/tests_update_ok.json
@@ -0,0 +1,6 @@
+{
+  "Issues": {},
+  "Success": true,
+  "Message": "",
+  "InsertID": 1234
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/ssl.go b/vendor/github.com/DreamItGetIT/statuscake/ssl.go
new file mode 100644
index 0000000..3f73d8d
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/ssl.go
@@ -0,0 +1,273 @@
+package statuscake
+
+import (
+        "encoding/json"
+        "fmt"
+        "net/url"
+        "strings"
+        "strconv"
+        
+        "github.com/google/go-querystring/query"
+)
+
+//Ssl represent the data received by the API with GET
+type Ssl struct {
+        ID             string              `json:"id"                 url:"id,omitempty"`
+        Domain         string              `json:"domain"             url:"domain,omitempty"`
+        Checkrate      int                 `json:"checkrate"          url:"checkrate,omitempty"`
+        ContactGroupsC string              `                          url:"contact_groups,omitempty"`
+        AlertAt        string              `json:"alert_at"           url:"alert_at,omitempty"`
+        AlertReminder  bool                `json:"alert_reminder"     url:"alert_expiry,omitempty"`
+        AlertExpiry    bool                `json:"alert_expiry"       url:"alert_reminder,omitempty"`
+        AlertBroken    bool                `json:"alert_broken"       url:"alert_broken,omitempty"`
+        AlertMixed     bool                `json:"alert_mixed"        url:"alert_mixed,omitempty"`
+        Paused         bool                `json:"paused"`
+        IssuerCn       string              `json:"issuer_cn"`
+        CertScore      string              `json:"cert_score"`
+        CipherScore    string              `json:"cipher_score"`
+        CertStatus     string              `json:"cert_status"`
+        Cipher         string              `json:"cipher"`
+        ValidFromUtc   string              `json:"valid_from_utc"`
+        ValidUntilUtc  string              `json:"valid_until_utc"`
+        MixedContent   []map[string]string `json:"mixed_content"`
+        Flags          map[string]bool     `json:"flags"`
+        ContactGroups  []string            `json:"contact_groups"`
+        LastReminder   int                 `json:"last_reminder"`
+        LastUpdatedUtc string              `json:"last_updated_utc"`
+}
+
+//PartialSsl represent  a ssl test creation or modification
+type PartialSsl struct {
+        ID             int
+        Domain         string
+        Checkrate      string
+        ContactGroupsC string
+        AlertAt        string
+        AlertExpiry    bool
+        AlertReminder  bool
+        AlertBroken    bool
+        AlertMixed     bool
+}
+
+type createSsl struct {
+        ID             int    `url:"id,omitempty"`
+        Domain         string `url:"domain"         json:"domain"`
+        Checkrate      string `url:"checkrate"      json:"checkrate"`
+        ContactGroupsC string `url:"contact_groups" json:"contact_groups"`
+        AlertAt        string `url:"alert_at"       json:"alert_at"`
+        AlertExpiry    bool   `url:"alert_expiry"   json:"alert_expiry"`
+        AlertReminder  bool   `url:"alert_reminder" json:"alert_reminder"`
+        AlertBroken    bool   `url:"alert_broken"   json:"alert_broken"`
+        AlertMixed     bool   `url:"alert_mixed"    json:"alert_mixed"`
+}
+
+type updateSsl struct {
+        ID             int    `url:"id"`
+        Domain         string `url:"domain"         json:"domain"`
+        Checkrate      string `url:"checkrate"      json:"checkrate"`
+        ContactGroupsC string `url:"contact_groups" json:"contact_groups"`
+        AlertAt        string `url:"alert_at"       json:"alert_at"`
+        AlertExpiry    bool   `url:"alert_expiry"   json:"alert_expiry"`
+        AlertReminder  bool   `url:"alert_reminder" json:"alert_reminder"`
+        AlertBroken    bool   `url:"alert_broken"   json:"alert_broken"`
+        AlertMixed     bool   `url:"alert_mixed"    json:"alert_mixed"`
+}
+
+
+type sslUpdateResponse struct {
+        Success bool   `json:"Success"`
+        Message interface{} `json:"Message"`
+}
+
+type sslCreateResponse struct {
+        Success bool   `json:"Success"`
+        Message interface{} `json:"Message"`
+        Input createSsl `json:"Input"`
+}
+
+//Ssls represent the actions done wit the API
+type Ssls interface {
+        All() ([]*Ssl, error)
+        completeSsl(*PartialSsl) (*Ssl, error)
+        Detail(string) (*Ssl, error)
+        Update(*PartialSsl) (*Ssl, error)
+        UpdatePartial(*PartialSsl) (*PartialSsl, error)
+        Delete(ID string) error
+        CreatePartial(*PartialSsl) (*PartialSsl, error)
+        Create(*PartialSsl) (*Ssl, error)
+}
+
+func consolidateSsl(s *Ssl) {
+        (*s).ContactGroupsC = strings.Trim(strings.Join(strings.Fields(fmt.Sprint((*s).ContactGroups)), ","), "[]")
+}
+
+func findSsl(responses []*Ssl, id string) (*Ssl, error) {
+        var response *Ssl
+        for _, elem := range responses {
+                if (*elem).ID == id {
+                        return elem, nil
+                }
+        }
+        return response, fmt.Errorf("%s Not found", id)
+}
+
+func (tt *ssls) completeSsl(s *PartialSsl) (*Ssl, error) {
+        full, err := tt.Detail(strconv.Itoa((*s).ID))
+        if err != nil {
+                return nil, err
+        }
+        (*full).ContactGroups = strings.Split((*s).ContactGroupsC,",")
+        return full, nil
+}
+
+//Partial return a PartialSsl corresponding to the Ssl
+func Partial(s *Ssl) (*PartialSsl,error) {
+        if s==nil {
+                return nil,fmt.Errorf("s is nil")
+        }
+        id,err:=strconv.Atoi(s.ID)
+        if(err!=nil){
+                return nil,err
+        }
+        return &PartialSsl{
+                ID: id,
+                Domain: s.Domain,
+                Checkrate: strconv.Itoa(s.Checkrate),
+                ContactGroupsC: s.ContactGroupsC,
+                AlertReminder: s.AlertReminder,
+                AlertExpiry: s.AlertExpiry,
+                AlertBroken: s.AlertBroken,
+                AlertMixed: s.AlertMixed,
+                AlertAt: s.AlertAt,
+        },nil
+        
+}
+
+type ssls struct {
+        client apiClient
+}
+
+//NewSsls return a new ssls
+func NewSsls(c apiClient) Ssls {
+        return &ssls{
+                client: c,
+        }
+}
+
+//All return a list of all the ssl from the API
+func (tt *ssls) All() ([]*Ssl, error) {
+        rawResponse, err := tt.client.get("/SSL", nil)
+        if err != nil {
+                return nil, fmt.Errorf("Error getting StatusCake Ssl: %s", err.Error())
+        }
+        var getResponse []*Ssl
+        err = json.NewDecoder(rawResponse.Body).Decode(&getResponse)
+        if err != nil {
+                return nil, err
+        }
+        
+        for ssl := range getResponse {
+                consolidateSsl(getResponse[ssl])
+        }
+        
+        return getResponse, err
+}
+
+//Detail return the ssl corresponding to the id 
+func (tt *ssls) Detail(id string) (*Ssl, error) {
+        responses, err := tt.All()
+        if err != nil {
+                return nil, err
+        }
+        mySsl, errF := findSsl(responses, id)
+        if errF != nil {
+                return nil, errF
+        }
+        return mySsl, nil
+}
+
+//Update update the API with s and create one if s.ID=0 then return the corresponding Ssl
+func (tt *ssls) Update(s *PartialSsl) (*Ssl, error) {
+        var err error
+        s, err = tt.UpdatePartial(s)
+        if err!= nil {
+                return nil, err
+        }
+        return tt.completeSsl(s)
+}
+
+//UpdatePartial update the API with s and create one if s.ID=0 then return the corresponding PartialSsl
+func (tt *ssls) UpdatePartial(s *PartialSsl) (*PartialSsl, error) {
+
+        if((*s).ID == 0){
+                return tt.CreatePartial(s)
+        }
+        var v url.Values
+
+        v, _ = query.Values(updateSsl(*s))
+        
+        rawResponse, err := tt.client.put("/SSL/Update", v)
+        if err != nil {
+                return nil, fmt.Errorf("Error creating StatusCake Ssl: %s", err.Error())
+        }
+        
+        var updateResponse sslUpdateResponse
+        err = json.NewDecoder(rawResponse.Body).Decode(&updateResponse)
+        if err != nil {
+                return nil, err
+        }
+        
+        if !updateResponse.Success {
+                return nil, fmt.Errorf("%s", updateResponse.Message.(string))
+        }
+
+
+        return s, nil
+}
+
+//Delete delete the ssl which ID is id
+func (tt *ssls) Delete(id string) error {
+        _, err := tt.client.delete("/SSL/Update", url.Values{"id": {fmt.Sprint(id)}})
+        if err != nil {
+                return err
+        }
+
+        return nil
+}
+
+//Create create the ssl whith the data in s and return the Ssl created
+func (tt *ssls) Create(s *PartialSsl) (*Ssl, error) {
+        var err error
+        s, err = tt.CreatePartial(s)
+        if err!= nil {
+                return nil, err
+        }
+        return tt.completeSsl(s)
+}
+
+//CreatePartial create the ssl whith the data in s and return the PartialSsl created
+func (tt *ssls) CreatePartial(s *PartialSsl) (*PartialSsl, error) {
+        (*s).ID=0
+        var v url.Values
+        v, _ = query.Values(createSsl(*s))
+        
+        rawResponse, err := tt.client.put("/SSL/Update", v)
+        if err != nil {
+                return nil, fmt.Errorf("Error creating StatusCake Ssl: %s", err.Error())
+        }
+
+        var createResponse sslCreateResponse
+        err = json.NewDecoder(rawResponse.Body).Decode(&createResponse)
+        if err != nil {
+                return nil, err
+        }
+
+        if !createResponse.Success {
+                return nil, fmt.Errorf("%s", createResponse.Message.(string))
+        }
+        *s = PartialSsl(createResponse.Input)
+        (*s).ID = int(createResponse.Message.(float64))
+        
+        return s,nil
+}
+
diff --git a/vendor/github.com/DreamItGetIT/statuscake/ssl_test.go b/vendor/github.com/DreamItGetIT/statuscake/ssl_test.go
new file mode 100644
index 0000000..48a961c
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/ssl_test.go
@@ -0,0 +1,343 @@
+package statuscake
+
+import (
+        "testing"
+        //"fmt"
+        "github.com/stretchr/testify/assert"
+        "github.com/stretchr/testify/require"
+        "net/url"
+)
+
+func TestSsl_All(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "sslListAllOk.json",
+        }
+        tt := NewSsls(c)
+        ssls, err := tt.All()
+        require.Nil(err)
+
+        assert.Equal("/SSL", c.sentRequestPath)
+        assert.Equal("GET", c.sentRequestMethod)
+        assert.Nil(c.sentRequestValues)
+        assert.Len(ssls, 3)
+        mixed := make(map[string]string)
+        flags := make(map[string]bool)
+        flags["is_extended"] = false
+        flags["has_pfs"] = true
+        flags["is_broken"] = false
+        flags["is_expired"] = false
+        flags["is_missing"] = false
+        flags["is_revoked"] = false
+        flags["has_mixed"] = false
+        expectedTest := &Ssl{
+                ID: "143615",
+                Checkrate: 2073600,
+                Paused: false,
+                Domain: "https://www.exemple.com",
+                IssuerCn: "Let's Encrypt Authority X3",
+                CertScore: "95",
+                CipherScore: "100",
+                CertStatus: "CERT_OK",
+                Cipher: "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+                ValidFromUtc: "2019-05-28 01:22:00",
+                ValidUntilUtc: "2019-08-26 01:22:00",
+                MixedContent: []map[string]string{},
+                Flags: flags,
+                ContactGroups: []string{},
+                ContactGroupsC: "",
+                AlertAt: "7,18,2019",
+                LastReminder: 2019,
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                LastUpdatedUtc: "2019-06-20 10:11:03",
+        }
+        assert.Equal(expectedTest, ssls[0])
+
+        expectedTest.ID="143617"
+        expectedTest.LastUpdatedUtc="2019-06-20 10:23:20"
+        assert.Equal(expectedTest, ssls[2])
+
+        expectedTest.ID="143616"
+        expectedTest.LastUpdatedUtc="2019-06-20 10:23:14"
+        mixed["type"]="img"
+        mixed["src"]="http://example.com/image.gif"
+        expectedTest.MixedContent=[]map[string]string{mixed}
+        expectedTest.ContactGroupsC="12,13,34"
+        expectedTest.ContactGroups=[]string{"12","13","34"}
+        assert.Equal(expectedTest, ssls[1])
+}
+
+func TestSsls_Detail_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "sslListAllOk.json",
+        }
+        tt := NewSsls(c)
+
+        ssl, err := tt.Detail("143616")
+        require.Nil(err)
+        assert.Equal("/SSL", c.sentRequestPath)
+        assert.Equal("GET", c.sentRequestMethod)
+        assert.Nil(c.sentRequestValues)
+        
+        mixed := make(map[string]string)
+        flags := make(map[string]bool)
+
+        mixed["type"]="img"
+        mixed["src"]="http://example.com/image.gif"
+        
+        flags["is_extended"] = false
+        flags["has_pfs"] = true
+        flags["is_broken"] = false
+        flags["is_expired"] = false
+        flags["is_missing"] = false
+        flags["is_revoked"] = false
+        flags["has_mixed"] = false
+        expectedTest := &Ssl{
+                ID: "143616",
+                Checkrate: 2073600,
+                Paused: false,
+                Domain: "https://www.exemple.com",
+                IssuerCn: "Let's Encrypt Authority X3",
+                CertScore: "95",
+                CipherScore: "100",
+                CertStatus: "CERT_OK",
+                Cipher: "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+                ValidFromUtc: "2019-05-28 01:22:00",
+                ValidUntilUtc: "2019-08-26 01:22:00",
+                MixedContent: []map[string]string{mixed},
+                Flags: flags,
+                ContactGroups: []string{"12","13","34"},
+                ContactGroupsC: "12,13,34",
+                AlertAt: "7,18,2019",
+                LastReminder: 2019,
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                LastUpdatedUtc: "2019-06-20 10:23:14",
+        }
+        
+        assert.Equal(expectedTest, ssl)
+}
+
+func TestSsls_CreatePartial_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "sslCreateOk.json",
+        }
+        tt := NewSsls(c)
+        partial := &PartialSsl{
+                Domain: "https://www.exemple.com",
+                Checkrate: "2073600",
+                ContactGroupsC: "",
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                AlertAt: "7,18,2019",
+        }
+        expectedRes := &PartialSsl {
+                ID: 143616,
+                Domain: "https://www.exemple.com",
+                Checkrate: "2073600",
+                ContactGroupsC: "",
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                AlertAt: "7,18,2019",
+        }
+        res, err := tt.CreatePartial(partial)
+        require.Nil(err)
+        assert.Equal("/SSL/Update", c.sentRequestPath)
+        assert.Equal("PUT", c.sentRequestMethod)
+        assert.Equal(c.sentRequestValues,url.Values(url.Values{"domain":[]string{"https://www.exemple.com"}, "checkrate":[]string{"2073600"}, "contact_groups":[]string{""}, "alert_at":[]string{"7,18,2019"}, "alert_expiry":[]string{"true"}, "alert_reminder":[]string{"true"}, "alert_broken":[]string{"true"}, "alert_mixed":[]string{"true"}}))
+
+        assert.Equal(expectedRes, res)
+}
+
+func TestSsls_UpdatePartial_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "sslUpdateOk.json",
+        }
+        tt := NewSsls(c)
+        partial := &PartialSsl{
+                ID: 143616,
+                Domain: "https://www.exemple.com",
+                Checkrate: "2073600",
+                ContactGroupsC: "",
+                AlertReminder: false,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                AlertAt: "7,18,2019",
+        }
+        expectedRes := &PartialSsl {
+                ID: 143616,
+                Domain: "https://www.exemple.com",
+                Checkrate: "2073600",
+                ContactGroupsC: "",
+                AlertReminder: false,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                AlertAt: "7,18,2019",
+        }
+        res, err := tt.UpdatePartial(partial)
+        require.Nil(err)
+        assert.Equal(expectedRes, res)
+        assert.Equal("/SSL/Update", c.sentRequestPath)
+        assert.Equal("PUT", c.sentRequestMethod)
+        assert.Equal(c.sentRequestValues,url.Values(url.Values{"id":[]string{"143616"},"domain":[]string{"https://www.exemple.com"}, "checkrate":[]string{"2073600"}, "contact_groups":[]string{""}, "alert_at":[]string{"7,18,2019"}, "alert_expiry":[]string{"true"}, "alert_reminder":[]string{"false"}, "alert_broken":[]string{"true"}, "alert_mixed":[]string{"true"}}))
+}
+
+func TestSsl_complete_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "sslListAllOk.json",
+        }
+        tt := NewSsls(c)
+
+        partial := &PartialSsl {
+                ID: 143616,
+                Domain: "https://www.exemple.com",
+                Checkrate: "2073600",
+                ContactGroupsC: "12,13,34",
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                AlertAt: "7,18,2019",
+        }
+        full, err := tt.completeSsl(partial)
+        require.Nil(err)
+        mixed := make(map[string]string)
+        flags := make(map[string]bool)
+
+        mixed["type"]="img"
+        mixed["src"]="http://example.com/image.gif"
+        
+        flags["is_extended"] = false
+        flags["has_pfs"] = true
+        flags["is_broken"] = false
+        flags["is_expired"] = false
+        flags["is_missing"] = false
+        flags["is_revoked"] = false
+        flags["has_mixed"] = false
+        expectedTest := &Ssl{
+                ID: "143616",
+                Checkrate: 2073600,
+                Paused: false,
+                Domain: "https://www.exemple.com",
+                IssuerCn: "Let's Encrypt Authority X3",
+                CertScore: "95",
+                CipherScore: "100",
+                CertStatus: "CERT_OK",
+                Cipher: "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+                ValidFromUtc: "2019-05-28 01:22:00",
+                ValidUntilUtc: "2019-08-26 01:22:00",
+                MixedContent: []map[string]string{mixed},
+                Flags: flags,
+                ContactGroups: []string{"12","13","34"},
+                ContactGroupsC: "12,13,34",
+                AlertAt: "7,18,2019",
+                LastReminder: 2019,
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                LastUpdatedUtc: "2019-06-20 10:23:14",
+        }
+        
+        assert.Equal(expectedTest, full)
+        
+}
+
+func TestSsl_partial_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+        
+        mixed := make(map[string]string)
+        flags := make(map[string]bool)
+
+        mixed["type"]="img"
+        mixed["src"]="http://example.com/image.gif"
+        
+        flags["is_extended"] = false
+        flags["has_pfs"] = true
+        flags["is_broken"] = false
+        flags["is_expired"] = false
+        flags["is_missing"] = false
+        flags["is_revoked"] = false
+        flags["has_mixed"] = false
+        full := &Ssl{
+                ID: "143616",
+                Checkrate: 2073600,
+                Paused: false,
+                Domain: "https://www.exemple.com",
+                IssuerCn: "Let's Encrypt Authority X3",
+                CertScore: "95",
+                CipherScore: "100",
+                CertStatus: "CERT_OK",
+                Cipher: "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+                ValidFromUtc: "2019-05-28 01:22:00",
+                ValidUntilUtc: "2019-08-26 01:22:00",
+                MixedContent: []map[string]string{mixed},
+                Flags: flags,
+                ContactGroups: []string{"12","13","34"},
+                ContactGroupsC: "12,13,34",
+                AlertAt: "7,18,2019",
+                LastReminder: 2019,
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                LastUpdatedUtc: "2019-06-20 10:23:14",
+        }
+        expectedTest:=&PartialSsl {
+                ID: 143616,
+                Domain: "https://www.exemple.com",
+                Checkrate: "2073600",
+                ContactGroupsC: "12,13,34",
+                AlertReminder: true,
+                AlertExpiry: true,
+                AlertBroken: true,
+                AlertMixed: true,
+                AlertAt: "7,18,2019",
+        }
+        partial,err:=Partial(full)
+        require.Nil(err)
+        assert.Equal(expectedTest, partial)
+        
+}
+
+func TestSsls_Delete_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "sslDeleteOk.json",
+        }
+        tt := NewSsls(c)
+
+        err := tt.Delete("143616")
+        require.Nil(err)
+        assert.Equal("/SSL/Update", c.sentRequestPath)
+        assert.Equal("DELETE", c.sentRequestMethod)
+        assert.Equal(c.sentRequestValues,url.Values(url.Values{"id":[]string{"143616"},},))
+}
diff --git a/vendor/github.com/DreamItGetIT/statuscake/tests_test.go b/vendor/github.com/DreamItGetIT/statuscake/tests_test.go
new file mode 100644
index 0000000..efeb720
--- /dev/null
+++ b/vendor/github.com/DreamItGetIT/statuscake/tests_test.go
@@ -0,0 +1,422 @@
+package statuscake
+
+import (
+        "bytes"
+        "encoding/json"
+        "io/ioutil"
+        "log"
+        "net/http"
+        "net/url"
+        "os"
+        "path/filepath"
+        "strings"
+        "testing"
+
+        "github.com/stretchr/testify/assert"
+        "github.com/stretchr/testify/require"
+)
+
+func TestTest_Validate(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        test := &Test{
+                Timeout:      200,
+                Confirmation: 100,
+                Public:       200,
+                Virus:        200,
+                TestType:     "FTP",
+                RealBrowser:  100,
+                TriggerRate:  100,
+                CheckRate:    100000,
+                CustomHeader: "here be dragons",
+                WebsiteName:  "",
+                WebsiteURL:   "",
+        }
+
+        err := test.Validate()
+        require.NotNil(err)
+
+        message := err.Error()
+        assert.Contains(message, "WebsiteName is required")
+        assert.Contains(message, "WebsiteURL is required")
+        assert.Contains(message, "Timeout must be 0 or between 6 and 99")
+        assert.Contains(message, "Confirmation must be between 0 and 9")
+        assert.Contains(message, "CheckRate must be between 0 and 23999")
+        assert.Contains(message, "Public must be 0 or 1")
+        assert.Contains(message, "Virus must be 0 or 1")
+        assert.Contains(message, "TestType must be HTTP, TCP, or PING")
+        assert.Contains(message, "RealBrowser must be 0 or 1")
+        assert.Contains(message, "TriggerRate must be between 0 and 59")
+        assert.Contains(message, "CustomHeader must be provided as json string")
+
+        test.Timeout = 10
+        test.Confirmation = 2
+        test.Public = 1
+        test.Virus = 1
+        test.TestType = "HTTP"
+        test.RealBrowser = 1
+        test.TriggerRate = 50
+        test.CheckRate = 10
+        test.WebsiteName = "Foo"
+        test.WebsiteURL = "http://example.com"
+        test.CustomHeader = `{"test": 15}`
+        test.NodeLocations = []string{"foo", "bar"}
+
+        err = test.Validate()
+        assert.Nil(err)
+}
+
+func TestTest_ToURLValues(t *testing.T) {
+        assert := assert.New(t)
+
+        test := &Test{
+                TestID:         123,
+                Paused:         true,
+                WebsiteName:    "Foo Bar",
+                CustomHeader:   `{"some":{"json": ["value"]}}`,
+                WebsiteURL:     "http://example.com",
+                Port:           3000,
+                NodeLocations:  []string{"foo", "bar"},
+                Timeout:        11,
+                PingURL:        "http://example.com/ping",
+                Confirmation:   1,
+                CheckRate:      500,
+                BasicUser:      "myuser",
+                BasicPass:      "mypass",
+                Public:         1,
+                LogoImage:      "http://example.com/logo.jpg",
+                Branding:       1,
+                WebsiteHost:    "hoster",
+                Virus:          1,
+                FindString:     "hello",
+                DoNotFind:      true,
+                TestType:       "HTTP",
+                RealBrowser:    1,
+                TriggerRate:    50,
+                TestTags:       []string{"tag1", "tag2"},
+                StatusCodes:    "500",
+                EnableSSLAlert: false,
+                FollowRedirect: false,
+        }
+
+        expected := url.Values{
+                "TestID":         {"123"},
+                "Paused":         {"1"},
+                "WebsiteName":    {"Foo Bar"},
+                "WebsiteURL":     {"http://example.com"},
+                "CustomHeader":   {`{"some":{"json": ["value"]}}`},
+                "Port":           {"3000"},
+                "NodeLocations":  {"foo,bar"},
+                "Timeout":        {"11"},
+                "PingURL":        {"http://example.com/ping"},
+                "ContactGroup":   {""},
+                "Confirmation":   {"1"},
+                "CheckRate":      {"500"},
+                "BasicUser":      {"myuser"},
+                "BasicPass":      {"mypass"},
+                "Public":         {"1"},
+                "LogoImage":      {"http://example.com/logo.jpg"},
+                "Branding":       {"1"},
+                "WebsiteHost":    {"hoster"},
+                "Virus":          {"1"},
+                "FindString":     {"hello"},
+                "DoNotFind":      {"1"},
+                "TestType":       {"HTTP"},
+                "RealBrowser":    {"1"},
+                "TriggerRate":    {"50"},
+                "TestTags":       {"tag1,tag2"},
+                "StatusCodes":    {"500"},
+                "UseJar":         {"0"},
+                "PostRaw":        {""},
+                "FinalEndpoint":  {""},
+                "EnableSSLAlert": {"0"},
+                "FollowRedirect": {"0"},
+        }
+
+        assert.Equal(expected, test.ToURLValues())
+
+        test.TestID = 0
+        delete(expected, "TestID")
+
+        assert.Equal(expected.Encode(), test.ToURLValues().Encode())
+}
+
+func TestTests_All(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_all_ok.json",
+        }
+        tt := newTests(c)
+        tests, err := tt.All()
+        require.Nil(err)
+
+        assert.Equal("/Tests", c.sentRequestPath)
+        assert.Equal("GET", c.sentRequestMethod)
+        assert.Nil(c.sentRequestValues)
+        assert.Len(tests, 2)
+
+        expectedTest := &Test{
+                TestID:        100,
+                Paused:        false,
+                TestType:      "HTTP",
+                WebsiteName:   "www 1",
+                ContactGroup:  []string{"1"},
+                Status:        "Up",
+                Uptime:        100,
+                NodeLocations: []string{"foo", "bar"},
+        }
+        assert.Equal(expectedTest, tests[0])
+
+        expectedTest = &Test{
+                TestID:        101,
+                Paused:        true,
+                TestType:      "HTTP",
+                WebsiteName:   "www 2",
+                ContactGroup:  []string{"2"},
+                Status:        "Down",
+                Uptime:        0,
+                NodeLocations: []string{"foo"},
+                TestTags:          []string{"test1", "test2"},
+        }
+        assert.Equal(expectedTest, tests[1])
+}
+
+func TestTests_AllWithFilter(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_all_ok.json",
+        }
+
+        v := url.Values{}
+        v.Set("tags", "test1,test2")
+        tt := newTests(c)
+        tests, err := tt.AllWithFilter(v)
+        require.Nil(err)
+
+        assert.Equal("/Tests", c.sentRequestPath)
+        assert.Equal("GET", c.sentRequestMethod)
+        assert.NotNil(c.sentRequestValues)
+        assert.Len(tests, 1)
+
+        expectedTest := &Test{
+                TestID:        101,
+                Paused:        true,
+                TestType:      "HTTP",
+                WebsiteName:   "www 2",
+                ContactGroup:  []string{"2"},
+                Status:        "Down",
+                Uptime:        0,
+                NodeLocations: []string{"foo"},
+                TestTags:          []string{"test1", "test2"},
+        }
+        assert.Equal(expectedTest, tests[0])
+}
+
+func TestTests_Update_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_update_ok.json",
+        }
+        tt := newTests(c)
+
+        test1 := &Test{
+                WebsiteName: "foo",
+        }
+
+        test2, err := tt.Update(test1)
+        require.Nil(err)
+
+        assert.Equal("/Tests/Update", c.sentRequestPath)
+        assert.Equal("PUT", c.sentRequestMethod)
+        assert.NotNil(c.sentRequestValues)
+        assert.NotNil(test2)
+
+        assert.Equal(1234, test2.TestID)
+}
+
+func TestTests_Update_Error(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_update_error.json",
+        }
+        tt := newTests(c)
+
+        test1 := &Test{
+                WebsiteName: "foo",
+        }
+
+        test2, err := tt.Update(test1)
+        assert.Nil(test2)
+
+        require.NotNil(err)
+        assert.IsType(&updateError{}, err)
+        assert.Contains(err.Error(), "issue a")
+}
+
+func TestTests_Update_ErrorWithSliceOfIssues(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_update_error_slice_of_issues.json",
+        }
+        tt := newTests(c)
+
+        test1 := &Test{
+                WebsiteName: "foo",
+        }
+
+        test2, err := tt.Update(test1)
+        assert.Nil(test2)
+
+        require.NotNil(err)
+        assert.IsType(&updateError{}, err)
+        assert.Equal("Required Data is Missing., hello, world", err.Error())
+}
+
+func TestTests_Delete_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_delete_ok.json",
+        }
+        tt := newTests(c)
+
+        err := tt.Delete(1234)
+        require.Nil(err)
+
+        assert.Equal("/Tests/Details", c.sentRequestPath)
+        assert.Equal("DELETE", c.sentRequestMethod)
+        assert.Equal(url.Values{"TestID": {"1234"}}, c.sentRequestValues)
+}
+
+func TestTests_Delete_Error(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_delete_error.json",
+        }
+        tt := newTests(c)
+
+        err := tt.Delete(1234)
+        require.NotNil(err)
+        assert.Equal("this is an error", err.Error())
+}
+
+func TestTests_Detail_OK(t *testing.T) {
+        assert := assert.New(t)
+        require := require.New(t)
+
+        c := &fakeAPIClient{
+                fixture: "tests_detail_ok.json",
+        }
+        tt := newTests(c)
+
+        test, err := tt.Detail(1234)
+        require.Nil(err)
+
+        assert.Equal("/Tests/Details", c.sentRequestPath)
+        assert.Equal("GET", c.sentRequestMethod)
+        assert.Equal(url.Values{"TestID": {"1234"}}, c.sentRequestValues)
+
+        assert.Equal(test.TestID, 6735)
+        assert.Equal(test.TestType, "HTTP")
+        assert.Equal(test.Paused, false)
+        assert.Equal(test.WebsiteName, "NL")
+        assert.Equal(test.CustomHeader, `{"some":{"json": ["value"]}}`)
+        assert.Equal(test.UserAgent, "product/version (comment)")
+        assert.Equal(test.ContactGroup, []string{"536"})
+        assert.Equal(test.Status, "Up")
+        assert.Equal(test.Uptime, 0.0)
+        assert.Equal(test.CheckRate, 60)
+        assert.Equal(test.Timeout, 40)
+        assert.Equal(test.LogoImage, "")
+        assert.Equal(test.WebsiteHost, "Various")
+        assert.Equal(test.FindString, "")
+        assert.Equal(test.DoNotFind, false)
+        assert.Equal(test.NodeLocations, []string{"foo", "bar"})
+}
+
+type fakeAPIClient struct {
+        sentRequestPath   string
+        sentRequestMethod string
+        sentRequestValues url.Values
+        fixture           string
+}
+
+func (c *fakeAPIClient) put(path string, v url.Values) (*http.Response, error) {
+        return c.all("PUT", path, v)
+}
+
+func (c *fakeAPIClient) delete(path string, v url.Values) (*http.Response, error) {
+        return c.all("DELETE", path, v)
+}
+
+func (c *fakeAPIClient) get(path string, v url.Values) (*http.Response, error) {
+        return c.all("GET", path, v)
+}
+
+func (c *fakeAPIClient) all(method string, path string, v url.Values) (*http.Response, error) {
+        c.sentRequestMethod = method
+        c.sentRequestPath = path
+        c.sentRequestValues = v
+
+        p := filepath.Join("fixtures", c.fixture)
+        f, err := os.Open(p)
+        if err != nil {
+                log.Fatal(err)
+        }
+
+        var resp *http.Response
+        if len(c.sentRequestValues.Get("tags")) > 0 {
+                var storedResponses []Test
+                var returnResponses []Test
+                byteValue, _ := ioutil.ReadAll(f)
+                json.Unmarshal(byteValue, &storedResponses)
+                requestedTags := strings.Split(c.sentRequestValues.Get("tags"), ",")
+
+                for _, storedResponse := range storedResponses {
+                        if len(requestedTags) > len(storedResponse.TestTags) { // if we are requesting more tags than whats stored then there are no matches
+                                continue
+                        }
+
+                        match := true
+                        for i, tag := range requestedTags {
+                                if tag != storedResponse.TestTags[i] {
+                                        match = false
+                                }
+                        }
+
+                        if match { // we can add it to the response now
+                                returnResponses = append(returnResponses, storedResponse)
+                        }
+                }
+
+                if len(returnResponses) == 0 {
+                        return nil, nil
+                }
+
+                newByteValue, _ := json.Marshal(&returnResponses)
+                resp = &http.Response{
+                        Body: ioutil.NopCloser(bytes.NewBuffer(newByteValue)),
+                }
+
+        } else {
+                resp = &http.Response{
+                        Body: f,
+                }
+        }
+
+        return resp, nil
+}