snitcher 0.3.2 → 0.4.0.pre1

data/lib/snitcher/api/error.rb

@@ -0,0 +1,73 @@
+module Snitcher::API
+  # Error is the base class for all API specific errors. For a full list of
+  # errors and how they can happen please refer to the API documentation.
+  #
+  # https://deadmanssnitch.com/docs/api/v1#error-reference
+  class Error < StandardError
+    attr_reader :type
+
+    def self.new(api_error)
+      type    = api_error.delete("type")
+      message = api_error.delete("error")
+
+      klass =
+        case type.to_s
+          # sign_in_incorrect is only returned when using username + password.
+          when "sign_in_incorrect";  AuthenticationError
+          # api_key_invalid is only returned when using the API key.
+          when "api_key_invalid";    AuthenticationError
+          when "plan_limit_reached"; PlanLimitReachedError
+          when "account_on_hold";    AccountOnHoldError
+          when "resource_not_found"; ResourceNotFoundError
+          when "resource_invalid";   ResourceInvalidError
+          else                       Error
+        end
+
+      error = klass.allocate
+      error.send(:initialize, type, message, api_error)
+      error
+    end
+
+    def initialize(type, message = nil, metadata = nil)
+      super(message)
+
+      @type     = type
+      @metadata = metadata || {}
+    end
+  end
+
+  # AuthenticationError is raised from API calls when the given credentials
+  # are invalid.
+  class AuthenticationError < Error; end
+
+  # PlanLimitReachedError is raised when a request fails due to that feature
+  # being limited by your current plan. Most likely this is due to having too
+  # many snitches.
+  class PlanLimitReachedError < Error; end
+
+  # AccountOnHoldError is raised when an account becomes delinquent due to
+  # payment being rejected. This can be thrown from an API request and this can
+  # be fixed by updating the credit card on file at:
+  #   https://deadmanssnitch.com/account/billing
+  class AccountOnHoldError < Error; end
+
+  # ResourceNotFoundError is raised when requesting a Snitch or other resource
+  # that does not exist or you do not have permission to.
+  class ResourceNotFoundError < Error; end
+
+  # ResourceInvalidError is raised when updating a resource and there are errors
+  # with the update.
+  class ResourceInvalidError < Error
+    def errors
+      @metadata.fetch("validations", []).each_with_object({}) do |tuple, memo|
+        memo[tuple["attribute"]] = tuple["message"]
+      end
+    end
+  end
+
+  # InternalServerError is raised when something bad has happened on our end.
+  # Hopefully it's nothing you did and we're already on the case getting it
+  # fixed. If you're able to trigger this regularly please contact us as we
+  # could use your help reproducing it.
+  class InternalServerError < Error; end
+end

data/lib/snitcher/api/snitch.rb

@@ -0,0 +1,44 @@
+class Snitcher::API::Snitch
+  attr_accessor :token, :name, :tags, :status, :checked_in_at,
+    :interval, :check_in_url, :created_at, :notes
+
+  # Public: Return a Snitcher::API::Snitch object based on a hash payload.
+  #
+  # Example
+  #
+  #   payload = {
+  #     "token" => "c2354d53d3",
+  #     "href" => "/v1/snitches/c2354d53d3",
+  #     "name" => "Daily Backups",
+  #     "tags" => [
+  #       "production",
+  #       "critical"
+  #     ],
+  #     "status" => "pending",
+  #     "checked_in_at" => "",
+  #     "type": {
+  #       "interval" => "daily"
+  #     },
+  #     "check_in_url" => "https://nosnch.in/c2354d53d3",
+  #     "created_at" => "2015-08-15T12:15:00.234Z",
+  #     "notes" => "Important user data.",
+  #   }
+  #
+  #   Snitcher::API::Snitch.new(payload)
+  #   => #<Snitcher::API::Snitch:0x007fdcf50ad2d0 @token="c2354d53d3",
+  #       @name="Daily Backups", @tags=["production", "critical"],
+  #       @status="pending", @checked_in_at=nil, @interval="daily",
+  #       @check_in_url="https://nosnch.in/c2354d53d3",
+  #       @created_at="2015-08-15T12:15:00.234Z", @notes="Important user data.">
+  def initialize(payload)
+    @token = payload["token"]
+    @name = payload["name"]
+    @tags = payload["tags"]
+    @status = payload["status"]
+    @checked_in_at = payload["checked_in_at"]
+    @interval = payload["type"]["interval"]
+    @check_in_url = payload["check_in_url"]
+    @created_at = payload["created_at"]
+    @notes = payload["notes"]
+  end
+end

data/lib/snitcher/version.rb

@@ -1,3 +1,3 @@
 module Snitcher
-  VERSION = "0.3.2"
+  VERSION = "0.4.0.pre1"
 end

data/snitcher.gemspec

@@ -17,6 +17,8 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
   spec.test_files  = spec.files.grep(/^spec/)
 
+  spec.required_ruby_version = ">= 1.9.3"
+
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake", "~> 10.1"
 end

data/spec/api/client_spec.rb

@@ -0,0 +1,454 @@
+require "spec_helper"
+require "snitcher/api/client"
+require "base64"
+require "securerandom"
+
+describe Snitcher::API::Client do
+  subject(:client) do
+    Snitcher::API::Client.new("key", endpoint: "http://api.dms.dev")
+  end
+
+  let(:stub_url)   { /api\.dms\.dev/ }
+  let(:snitch_url) { "http://key:@api.dms.dev/v1/snitches" }
+
+  describe "#snitches" do
+    let(:url)   { snitch_url }
+    let(:body)  { '[
+                     {
+                       "token": "agr0683qp4",
+                       "href": "/v1/snitches/agr0683qp4",
+                       "name": "Cool Test Snitch",
+                       "tags": [
+                         "testing",
+                         "api"
+                       ],
+                       "status": "pending",
+                       "checked_in_at": "",
+                       "type": {
+                         "interval": "hourly"
+                       }
+                     },
+                     {
+                       "token": "xyz8574uy2",
+                       "href": "/v1/snitches/xyz8574uy2",
+                       "name": "Even Cooler Test Snitch",
+                       "tags": [
+                         "testing"
+                       ],
+                       "status": "pending",
+                       "checked_in_at": "",
+                       "type": {
+                         "interval": "hourly"
+                       }
+                     }
+                   ]'
+                }
+
+    before do
+      stub_request(:get, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.snitches
+
+      expect(a_request(:get, url)).to have_been_made.once
+    end
+
+    it "returns the array of snitches" do
+      expect(client.snitches).to be_a(Array)
+      expect(client.snitches.first).to be_a(Snitcher::API::Snitch)
+    end
+  end
+
+  describe "#snitch" do
+    let(:token) { "c2354d53d2" }
+    let(:url)   { "#{snitch_url}/#{token}" }
+    let(:body)  { '{
+                     "token": "c2354d53d2",
+                     "href": "/v1/snitches/c2354d53d2",
+                     "name": "Cool Test Snitch",
+                     "tags": [
+                       "testing",
+                       "api"
+                     ],
+                     "status": "pending",
+                     "checked_in_at": "",
+                     "type": {
+                       "interval": "hourly"
+                     },
+                     "check_in_url": "https://nosnch.in/c2354d53d2",
+                     "created_at": "2015-08-15T12:15:00.234Z",
+                     "notes": "Save everything that is cool."
+                   }'
+                }
+
+    before do
+      stub_request(:get, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.snitch(token)
+
+      expect(a_request(:get, url)).to have_been_made.once
+    end
+
+    it "returns the snitch" do
+      expect(client.snitch(token)).to be_a(Snitcher::API::Snitch)
+    end
+  end
+
+  describe "#tagged_snitches" do
+    let(:tags)  { ["sneetch", "belly"] }
+    let(:url)   { "#{snitch_url}?tags=sneetch,belly" }
+    let(:body)  { '[
+                     {
+                       "token": "c2354d53d2",
+                       "href": "/v1/snitches/c2354d53d2",
+                       "name": "Best Kind of Sneetch on the Beach",
+                       "tags": [
+                         "sneetch",
+                         "belly",
+                         "star-belly"
+                       ],
+                       "status": "pending",
+                       "checked_in_at": "",
+                       "type": {
+                         "interval": "hourly"
+                       }
+                     },
+                     {
+                       "token": "c2354d53d3",
+                       "href": "/v1/snitches/c2354d53d3",
+                       "name": "Have None Upon Thars",
+                       "tags": [
+                         "sneetch",
+                         "belly",
+                         "plain-belly"
+                       ],
+                       "status": "pending",
+                       "checked_in_at": "",
+                       "type": {
+                         "interval": "hourly"
+                       }
+                     }
+                   ]'
+                }
+
+    before do
+      stub_request(:get, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.tagged_snitches(tags)
+
+      expect(a_request(:get, url)).to have_been_made.once
+    end
+
+    it "returns the snitches" do
+      expect(client.tagged_snitches(tags)).to be_a(Array)
+      expect(client.tagged_snitches(tags).first).to be_a(Snitcher::API::Snitch)
+    end
+
+    it "supports spaces in tags" do
+      request = stub_request(:get, "#{snitch_url}?tags=phoenix%20foundary,murggle").
+        to_return(body: body, status: 200)
+
+      client.tagged_snitches("phoenix foundary", "murggle")
+
+      expect(request).to have_been_made.once
+    end
+
+    it "allows an array to be passed for tags" do
+      request = stub_request(:get, "#{snitch_url}?tags=murggle,gurgggle").
+        to_return(body: body, status: 200)
+
+      client.tagged_snitches(["murggle", "gurgggle"])
+
+      expect(request).to have_been_made.once
+    end
+  end
+
+  describe "#create_snitch" do
+    let(:data)  {
+                  {
+                    "name"     => "Daily Backups",
+                    "interval" => "daily",
+                    "notes"    => "Customer and supplier tables",
+                    "tags"     => ["backups", "maintenance"]
+                   }
+                }
+    let(:url)   { snitch_url }
+    let(:body)  { '{
+                     "token": "c2354d53d2",
+                     "href": "/v1/snitches/c2354d53d2",
+                     "name": "Daily Backups",
+                     "tags": [
+                       "backups",
+                       "maintenance"
+                     ],
+                     "status": "pending",
+                     "checked_in_at": "",
+                     "type": {
+                       "interval": "daily"
+                     },
+                     "check_in_url": "https://nosnch.in/c2354d53d2",
+                     "created_at": "2015-08-27T18:30:23.737Z",
+                     "notes": "Customer and supplier tables"
+                   }'
+                }
+
+    before do
+      stub_request(:post, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.create_snitch(data)
+
+      expect(a_request(:post, url)).to have_been_made.once
+    end
+
+    it "returns the new snitch" do
+      expect(client.create_snitch(data)).to be_a(Snitcher::API::Snitch)
+    end
+
+    describe "validation errors" do
+      let(:data) do
+        {
+          "name"     => "",
+          "interval" => "",
+        }
+      end
+
+      let(:body) do
+        '{
+           "type": "resource_invalid",
+           "error": "resource invalid",
+           "validations": [
+             { "attribute": "name", "message": "Can\'t be blank."},
+             { "attribute": "type.interval", "message": "Can\'t be blank."}
+           ]
+         }'
+      end
+
+      it "raises ResourceInvalidError if invalid" do
+        stub_request(:post, stub_url).to_return(:body => body, :status => 422)
+
+        expect {
+          client.create_snitch(data)
+        }.to raise_error(Snitcher::API::ResourceInvalidError) { |error|
+          expect(error.errors).to eq({
+            "name"          => "Can't be blank.",
+            "type.interval" => "Can't be blank.",
+          })
+        }
+      end
+    end
+  end
+
+  describe "#edit_snitch" do
+    let(:token) { "c2354d53d2" }
+    let(:data)  {
+                  {
+                    "interval" => "hourly",
+                    "notes"    => "We need this more often",
+                   }
+                }
+    let(:url)   { "#{snitch_url}/#{token}" }
+    let(:body)  { '{
+                     "token": "c2354d53d2",
+                     "href": "/v1/snitches/c2354d53d2",
+                     "name": "The Backups",
+                     "tags": [
+                       "backups",
+                       "maintenance"
+                     ],
+                     "status": "pending",
+                     "checked_in_at": "",
+                     "type": {
+                       "interval": "hourly"
+                     },
+                     "notes": "We need this more often"
+                   }'
+                }
+
+    before do
+      stub_request(:patch, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.edit_snitch(token, data)
+
+      expect(a_request(:patch, url)).to have_been_made.once
+    end
+
+    it "returns the modified snitch" do
+      expect(client.edit_snitch(token, data)).to be_a(Snitcher::API::Snitch)
+    end
+  end
+
+  describe "#add_tags" do
+    let(:token) { "c2354d53d2" }
+    let(:tags)  { ["red", "green"] }
+    let(:url)   { "#{snitch_url}/#{token}/tags" }
+    let(:body)  { '[
+                     "red",
+                     "green"
+                   ]'
+                }
+
+    before do
+      stub_request(:post, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.add_tags(token, tags)
+
+      expect(a_request(:post, url)).to have_been_made.once
+    end
+
+    context "when successful" do
+      it "returns an array of the snitch's tags" do
+        expect(client.add_tags(token, tags)).to eq(JSON.parse(body))
+      end
+    end
+  end
+
+  describe "#remove_tag" do
+    let(:token) { "c2354d53d2" }
+    let(:tag)   { "critical" }
+    let(:url)   { "#{snitch_url}/#{token}/tags/#{tag}" }
+    let(:body)  { '[
+                     "critical"
+                   ]'
+                }
+
+    before do
+      stub_request(:delete, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.remove_tag(token, tag)
+
+      expect(a_request(:delete, url)).to have_been_made.once
+    end
+
+    context "when successful" do
+      it "returns an array of the snitch's remaining tags" do
+        expect(client.remove_tag(token, tag)).to eq(JSON.parse(body))
+      end
+    end
+  end
+
+  describe "#replace_tags" do
+    let(:token) { "c2354d53d2" }
+    let(:tags)  { ["red", "green"] }
+    let(:url)   { "#{snitch_url}/#{token}" }
+    let(:body)  { '{
+                     "token": "c2354d53d2",
+                     "href": "/v1/snitches/c2354d53d2",
+                     "name": "Daily Backups",
+                     "tags": [
+                       "red",
+                       "green"
+                     ],
+                     "status": "pending",
+                     "checked_in_at": "",
+                     "type": {
+                       "interval": "daily"
+                     },
+                     "notes": "Sales data."
+                   }'
+                }
+
+    before do
+      stub_request(:patch, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.replace_tags(token, tags)
+
+      expect(a_request(:patch, url)).to have_been_made.once
+    end
+
+    it "returns the updated snitch" do
+      expect(client.replace_tags(token, tags)).to be_a(Snitcher::API::Snitch)
+    end
+  end
+
+  describe "#clear_tags" do
+    let(:token) { "c2354d53d2" }
+    let(:url)   { "#{snitch_url}/#{token}" }
+    let(:body)  { '{
+                     "token": "c2354d53d2",
+                     "href": "/v1/snitches/c2354d53d2",
+                     "name": "Daily Backups",
+                     "tags": [
+                     ],
+                     "status": "pending",
+                     "checked_in_at": "",
+                     "type": {
+                       "interval": "daily"
+                     },
+                     "notes": "Sales data."
+                   }'
+                }
+
+    before do
+      stub_request(:patch, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.clear_tags(token)
+
+      expect(a_request(:patch, url)).to have_been_made.once
+    end
+
+    it "returns the updated snitch" do
+      expect(client.clear_tags(token)).to be_a(Snitcher::API::Snitch)
+    end
+  end
+
+  describe "#pause_snitch" do
+    let(:token) { "c2354d53d2" }
+    let(:url)   { "#{snitch_url}/#{token}/pause" }
+    let(:body)  { '{}' }
+
+    before do
+      stub_request(:post, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.pause_snitch(token)
+
+      expect(a_request(:post, url)).to have_been_made.once
+    end
+
+    context "when successful" do
+      it "returns an empty response" do
+        expect(client.pause_snitch(token)).to eq(JSON.parse(body))
+      end
+    end
+  end
+
+  describe "#delete_snitch" do
+    let(:token) { "c2354d53d2" }
+    let(:url)   { "#{snitch_url}/#{token}" }
+    let(:body)  { '{}' }
+
+    before do
+      stub_request(:delete, stub_url).to_return(:body => body, :status => 200)
+    end
+
+    it "pings API with the api_key" do
+      client.delete_snitch(token)
+
+      expect(a_request(:delete, url)).to have_been_made.once
+    end
+
+    context "when successful" do
+      it "returns an empty response" do
+        expect(client.delete_snitch(token)).to eq(JSON.parse(body))
+      end
+    end
+  end
+end