github.com/naphatkrit/deis@v1.12.3/client/controller/models/certs/certs_test.go (about)

     1  package certs
     2  
     3  import (
     4  	"fmt"
     5  	"io/ioutil"
     6  	"net/http"
     7  	"net/http/httptest"
     8  	"net/url"
     9  	"reflect"
    10  	"testing"
    11  
    12  	"github.com/deis/deis/client/controller/api"
    13  	"github.com/deis/deis/client/controller/client"
    14  	"github.com/deis/deis/version"
    15  )
    16  
    17  const certsFixture string = `
    18  {
    19      "count": 1,
    20      "next": null,
    21      "previous": null,
    22      "results": [
    23          {
    24              "common_name": "test.example.com",
    25              "expires": "2014-01-01T00:00:00UTC"
    26          }
    27      ]
    28  }`
    29  
    30  const certFixture string = `
    31  {
    32      "updated": "2014-01-01T00:00:00UTC",
    33      "created": "2014-01-01T00:00:00UTC",
    34      "expires": "2015-01-01T00:00:00UTC",
    35      "common_name": "test.example.com",
    36      "owner": "test",
    37      "id": 1
    38  }`
    39  
    40  const certExpected string = `{"certificate":"test","key":"foo","common_name":"test.example.com"}`
    41  
    42  type fakeHTTPServer struct{}
    43  
    44  func (fakeHTTPServer) ServeHTTP(res http.ResponseWriter, req *http.Request) {
    45  	res.Header().Add("DEIS_API_VERSION", version.APIVersion)
    46  
    47  	if req.URL.Path == "/v1/certs/" && req.Method == "GET" {
    48  		res.Write([]byte(certsFixture))
    49  		return
    50  	}
    51  
    52  	if req.URL.Path == "/v1/certs/" && req.Method == "POST" {
    53  		body, err := ioutil.ReadAll(req.Body)
    54  
    55  		if err != nil {
    56  			fmt.Println(err)
    57  			res.WriteHeader(http.StatusInternalServerError)
    58  			res.Write(nil)
    59  		}
    60  
    61  		if string(body) != certExpected {
    62  			fmt.Printf("Expected '%s', Got '%s'\n", certExpected, body)
    63  			res.WriteHeader(http.StatusInternalServerError)
    64  			res.Write(nil)
    65  			return
    66  		}
    67  		res.WriteHeader(http.StatusCreated)
    68  		res.Write([]byte(certFixture))
    69  		return
    70  	}
    71  
    72  	if req.URL.Path == "/v1/certs/test.example.com" && req.Method == "DELETE" {
    73  		res.WriteHeader(http.StatusNoContent)
    74  		res.Write(nil)
    75  		return
    76  	}
    77  
    78  	fmt.Printf("Unrecognized URL %s\n", req.URL)
    79  	res.WriteHeader(http.StatusNotFound)
    80  	res.Write(nil)
    81  }
    82  
    83  func TestCertsList(t *testing.T) {
    84  	t.Parallel()
    85  
    86  	expected := []api.Cert{
    87  		api.Cert{
    88  			Name:    "test.example.com",
    89  			Expires: "2014-01-01T00:00:00UTC",
    90  		},
    91  	}
    92  
    93  	handler := fakeHTTPServer{}
    94  	server := httptest.NewServer(handler)
    95  	defer server.Close()
    96  
    97  	u, err := url.Parse(server.URL)
    98  
    99  	if err != nil {
   100  		t.Fatal(err)
   101  	}
   102  
   103  	httpClient := client.CreateHTTPClient(false)
   104  
   105  	client := client.Client{HTTPClient: httpClient, ControllerURL: *u, Token: "abc"}
   106  
   107  	actual, _, err := List(&client, 100)
   108  
   109  	if err != nil {
   110  		t.Fatal(err)
   111  	}
   112  
   113  	if !reflect.DeepEqual(expected, actual) {
   114  		t.Errorf("Expected %v, Got %v", expected, actual)
   115  	}
   116  }
   117  
   118  func TestCert(t *testing.T) {
   119  	t.Parallel()
   120  
   121  	expected := api.Cert{
   122  		Updated: "2014-01-01T00:00:00UTC",
   123  		Created: "2014-01-01T00:00:00UTC",
   124  		Expires: "2015-01-01T00:00:00UTC",
   125  		Name:    "test.example.com",
   126  		Owner:   "test",
   127  		ID:      1,
   128  	}
   129  
   130  	handler := fakeHTTPServer{}
   131  	server := httptest.NewServer(handler)
   132  	defer server.Close()
   133  
   134  	u, err := url.Parse(server.URL)
   135  
   136  	if err != nil {
   137  		t.Fatal(err)
   138  	}
   139  
   140  	httpClient := client.CreateHTTPClient(false)
   141  
   142  	client := client.Client{HTTPClient: httpClient, ControllerURL: *u, Token: "abc"}
   143  
   144  	actual, err := New(&client, "test", "foo", "test.example.com")
   145  
   146  	if err != nil {
   147  		t.Fatal(err)
   148  	}
   149  
   150  	if !reflect.DeepEqual(expected, actual) {
   151  		t.Errorf("Expected %v, Got %v", expected, actual)
   152  	}
   153  }
   154  
   155  func TestCertDeleteion(t *testing.T) {
   156  	t.Parallel()
   157  
   158  	handler := fakeHTTPServer{}
   159  	server := httptest.NewServer(handler)
   160  	defer server.Close()
   161  
   162  	u, err := url.Parse(server.URL)
   163  
   164  	if err != nil {
   165  		t.Fatal(err)
   166  	}
   167  
   168  	httpClient := client.CreateHTTPClient(false)
   169  
   170  	client := client.Client{HTTPClient: httpClient, ControllerURL: *u, Token: "abc"}
   171  
   172  	if err = Delete(&client, "test.example.com"); err != nil {
   173  		t.Fatal(err)
   174  	}
   175  }