Merge pull request #1 from clearip/new-structure

New structure

Author: AbdullahDiaa

Diff for: .travis.yml

@@ -0,0 +1,33 @@
+
+# This is a weird way of telling Travis to use the fast container-based test
+# runner instead of the slow VM-based runner.
+sudo: false
+
+language: go
+
+# Force-enable Go modules. This will be unnecessary when Go 1.12 lands.
+env:
+  - GO111MODULE=on
+
+# You don't need to test on very old version of the Go compiler. It's the user's
+# responsibility to keep their compilers up to date.
+go:
+  - 1.11.x
+
+# Only clone the most recent commit.
+git:
+  depth: 1
+
+# Skip the install step. Don't `go get` dependencies. Only build with the code
+# in vendor/
+install: true
+
+# Don't email me the results of the test runs.
+notifications:
+  email: false
+
+# script always runs to completion (set +e). If we have linter issues AND a
+# failing test, we want to see both. Configure golangci-lint with a
+# .golangci.yml file at the top level of your repo.
+script:
+  - go test -v -race ./...  # Run all the tests with the race detector enabled

Diff for: client.go

@@ -1,63 +1,31 @@
 package clearip
 
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"regexp"
-	"strings"
-	"time"
-)
+import "fmt"
 
-// Client is wrapper for net/http client with additional variables
+// Client main client for clear ip
 type Client struct {
-	APIKey string
-	URL    string
-	HTTP   *http.Client
+	HTTPClient CLHTTPClient
+	IPRepo     IPInfoRepository
+	BaseURI    string
+	APIKey     string
 }
 
-// NewClient returns custome http client
+// BaseURI base url for clearip
+const defaultBaseURI = "https://api.clearip.io"
+
+// NewClient returns a new ClearIp API client, configured with default HTTPClient.
 func NewClient(apiKey string) (*Client, error) {
 
 	if len(apiKey) == 0 {
 		return nil, fmt.Errorf("API key required")
 	}
-
-	httpClient := &http.Client{
-		Timeout: time.Second * 10,
-	}
-	return &Client{
-		URL:    "https://api.clearip.io",
-		APIKey: apiKey,
-		HTTP:   httpClient,
-	}, nil
+	clearip := Client{APIKey: apiKey, BaseURI: defaultBaseURI}
+	clearip.HTTPClient = NewHTTPClient(clearip.APIKey, clearip.BaseURI)
+	clearip.setup()
+	return &clearip, nil
 }
 
-// GetIpinfo send a get request for ip info
-func (c *Client) GetIpinfo(ip string) (map[string]interface{}, error) {
-
-	matches, _ := regexp.MatchString(`^(([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([1-9]?[0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$`, ip)
-	if !matches {
-		return nil, fmt.Errorf("Ip required")
-	}
-
-	getIPInfoURL := strings.Join([]string{c.URL, "/ip/", ip, "/json?apikey=", c.APIKey}, "")
-	resp, err := c.HTTP.Get(getIPInfoURL)
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("auth error")
-	}
-
-	var response = make(map[string]interface{})
-
-	dec := json.NewDecoder(resp.Body)
-	if err := dec.Decode(&response); err != nil {
-		return nil, fmt.Errorf("error parsing json")
-	}
-
-	return response, nil
+func (c *Client) setup() {
+	c.IPRepo = IPInfoAPI{HTTP: c.HTTPClient}
 
 }

Diff for: fixtures/ipinfo.json

@@ -0,0 +1,98 @@
+{
+   "country":"Egypt",
+   "continent":"Africa",
+   "country_falg":"🇪🇬",
+   "CountryCode":"EG",
+   "City":"Cairo",
+   "Region":"Cairo Governorate",
+   "lat":30.0771,
+   "lng":31.2859,
+   "tz":"Africa/Cairo",
+   "isp":"Link Egypt",
+   "is_anonymous_proxy":false,
+   "is_satellite_provider":false,
+   "currency":[
+      "EGP"
+   ],
+   "country_details":{
+      "name":{
+         "common":"Egypt",
+         "official":"Arab Republic of Egypt",
+         "Native":{
+            "ara":{
+               "common":"مصر",
+               "official":"جمهورية مصر العربية"
+            }
+         }
+      },
+      "EuMember":false,
+      "LandLocked":false,
+      "Nationality":"",
+      "tld":[
+         ".eg",
+         ".مصر"
+      ],
+      "Languages":{
+         "ara":"Arabic"
+      },
+      "Translations":{
+         "DEU":{
+            "common":"Ägypten",
+            "official":"Arabische Republik Ägypten"
+         },
+         "FIN":{
+            "common":"Egypti",
+            "official":"Egyptin arabitasavalta"
+         },
+         "HRV":{
+            "common":"Egipat",
+            "official":"Arapska Republika Egipat"
+         },
+         "JPN":{
+            "common":"エジプト",
+            "official":"エジプト·アラブ共和国"
+         },
+         "NLD":{
+            "common":"Egypte",
+            "official":"Arabische Republiek Egypte"
+         },
+         "POR":{
+            "common":"Egito",
+            "official":"República Árabe do Egipto"
+         },
+         "RUS":{
+            "common":"Египет",
+            "official":"Арабская Республика Египет"
+         }
+      },
+      "currency":[
+         "EGP"
+      ],
+      "Borders":[
+         "ISR",
+         "LBY",
+         "SDN"
+      ],
+      "cca2":"EG",
+      "cca3":"EGY",
+      "CIOC":"EGY",
+      "CCN3":"818",
+      "callingCode":[
+         "20"
+      ],
+      "InternationalPrefix":"00",
+      "region":"Africa",
+      "subregion":"Northern Africa",
+      "Continent":"Africa",
+      "capital":"Cairo",
+      "Area":1002450,
+      "longitude":"30 00 E",
+      "latitude":"27 00 N",
+      "MinLongitude":24.7,
+      "MinLatitude":20.383333,
+      "MaxLongitude":36.333332,
+      "MaxLatitude":31.916668,
+      "Latitude":26.756104,
+      "Longitude":29.862297
+   }
+}

Diff for: http_client.go

@@ -0,0 +1,84 @@
+package clearip
+
+import (
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/google/go-querystring/query"
+)
+
+// HTTPClient -
+type HTTPClient interface {
+	Get(string, interface{}) ([]byte, error)
+}
+
+// CLHTTPClient - impelemts HTTPClient interface clear ip default client
+type CLHTTPClient struct {
+	*http.Client
+	BaseURI string
+	APIKey  string
+}
+
+//NewHTTPClient - create the clear ip client with api key
+func NewHTTPClient(apiKey string, BaseURI string) CLHTTPClient {
+	return CLHTTPClient{Client: &http.Client{
+		Timeout: time.Second * 10,
+	},
+		APIKey:  apiKey,
+		BaseURI: BaseURI,
+	}
+}
+
+// Get default http client
+func (c CLHTTPClient) Get(url string, queryParams interface{}) ([]byte, error) {
+	// Setup request
+	req, _ := http.NewRequest("GET", c.BaseURI+url+"?apikey="+c.APIKey, nil)
+	req.Header.Add("Accept", "application/json")
+	if queryParams != nil {
+		addQueryParams(req, queryParams)
+	}
+	// Do request
+	resp, err := c.Client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	// Read response
+	data, err := c.readAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode >= 400 {
+		return nil, c.parseResponseError(data, resp.StatusCode)
+	}
+	return data, err
+}
+
+func (c CLHTTPClient) parseResponseError(data []byte, statusCode int) HTTPError {
+	errorList := HTTPErrorList{}
+	err := json.Unmarshal(data, &errorList)
+	if err != nil {
+		return NewUnknownHTTPError(statusCode)
+	}
+	if len(errorList.Errors) == 0 {
+		return NewUnknownHTTPError(statusCode)
+	}
+	httpError := errorList.Errors[0]
+	httpError.StatusCode = statusCode
+	return httpError // only care about the first
+}
+
+func (c CLHTTPClient) readAll(body io.Reader) ([]byte, error) {
+	b, err := ioutil.ReadAll(body)
+
+	return b, err
+}
+
+func addQueryParams(req *http.Request, params interface{}) {
+	v, _ := query.Values(params)
+	req.URL.RawQuery = v.Encode()
+}

Diff for: http_client_test.go

@@ -0,0 +1,5 @@
+package clearip
+
+type TestHTTPClient struct{}
+
+func (h TestHTTPClient) Get(uri string, queryParams interface{}) ([]byte, error) { return nil, nil }

Diff for: http_error.go

@@ -0,0 +1,47 @@
+package clearip
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// HTTPErrorList -
+type HTTPErrorList struct {
+	Type   string      `json:"type"`
+	Errors []HTTPError `json:"errors"`
+}
+
+// HTTPError -
+type HTTPError struct {
+	StatusCode int
+	Code       string `json:"code"`
+	Message    string `json:"message"`
+}
+
+// NewUnknownHTTPError -
+func NewUnknownHTTPError(statusCode int) HTTPError {
+	message := http.StatusText(statusCode)
+	if message == "" {
+		message = "Unknown Error"
+	}
+	return HTTPError{Code: "Unknown", Message: message, StatusCode: statusCode}
+}
+
+func (e HTTPError) Error() string {
+	return fmt.Sprintf("%d: %s, %s", e.StatusCode, e.Code, e.Message)
+}
+
+// GetStatusCode -
+func (e HTTPError) GetStatusCode() int {
+	return e.StatusCode
+}
+
+// GetCode -
+func (e HTTPError) GetCode() string {
+	return e.Code
+}
+
+// GetMessage -
+func (e HTTPError) GetMessage() string {
+	return e.Message
+}