etre-client 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7ee88bbc4eaef62c80b7fe886975cc09f6fe3fa
+  data.tar.gz: 474060e882a53a6274772f2b21854651295d43f5
+SHA512:
+  metadata.gz: 5e3ec873dbc34c866833116196fce1b87a463a9f45360786bb48e6afb5c306bc1d7911a3c1d944736e81dee8dba6679793bf31afbeb63a2ad406b91930ea49d9
+  data.tar.gz: b993c6f228ac3bc21f941d4a2cbd2b86eb0f43058a8e3e9a27da4082555507668312bcf446a257ce7eb0b9d1b19bb8cdbbd2fa3fee9fadbd19c38fef80e0413d

data/.gitignore

@@ -0,0 +1,2 @@
+# ignore gems
+*.gem

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'rest-client'
+
+group :test, :development do
+  gem 'rspec-rails'
+end

data/Gemfile.lock

@@ -0,0 +1,97 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (5.1.4)
+      actionview (= 5.1.4)
+      activesupport (= 5.1.4)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.1.4)
+      activesupport (= 5.1.4)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    builder (3.2.3)
+    concurrent-ruby (1.0.5)
+    crass (1.0.2)
+    diff-lcs (1.3)
+    domain_name (0.5.20170404)
+      unf (>= 0.0.5, < 1.0.0)
+    erubi (1.7.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    i18n (0.9.0)
+      concurrent-ruby (~> 1.0)
+    loofah (2.1.1)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (0.9.0)
+    mime-types (3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2016.0521)
+    mini_portile2 (2.3.0)
+    minitest (5.10.3)
+    netrc (0.11.0)
+    nokogiri (1.8.1)
+      mini_portile2 (~> 2.3.0)
+    rack (2.0.3)
+    rack-test (0.7.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.3)
+      loofah (~> 2.0)
+    railties (5.1.4)
+      actionpack (= 5.1.4)
+      activesupport (= 5.1.4)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (12.2.1)
+    rest-client (2.0.2)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-rails (3.7.1)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+    thor (0.20.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rest-client
+  rspec-rails
+
+BUNDLED WITH
+   1.15.4

data/README.md

@@ -0,0 +1,74 @@
+Description
+------
+etre-client is a gem that can be used to interact with an [Etre](https://github.com/square/etre) instance.
+
+Installation
+------
+etre-client is hosted on rubygems.org. To install it
+1. Add "etre-client" to your Gemfile
+2. Run "bunndle install"
+
+Alternatively, you can just "gem install etre-client".
+
+Usage
+------
+Create a new client
+```
+e = Etre::Client.new(entity_type: "node", url: "http://127.0.0.1:8080")
+```
+
+Insert entities
+```
+entities = [{"foo" => "bar"}, {"foo" => "abc"}]
+e.insert(entities)
+=> [{"id"=>"59f90caadd1b176f02eddcd8", "uri"=>"127.0.0.1:8080/api/v1/entity/59f90caadd1b176f02eddcd8"}, {"id"=>"59f90caadd1b176f02eddcda", "uri"=>"127.0.0.1:8080/api/v1/entity/59f90caadd1b176f02eddcda"}]
+```
+
+Update entities
+```
+query = "foo=bar"
+patch = {"foo" => "newbar"}
+e.update(query, patch)
+=> [{"id"=>"59f90caadd1b176f02eddcd8", "uri"=>"127.0.0.1:8080/api/v1/entity/59f90caadd1b176f02eddcd8", "diff"=>{"_id"=>"59f90caadd1b176f02eddcd8", "_rev"=>0, "_type"=>"node", "foo"=>"bar"}}]
+```
+
+Update a single entity
+```
+id = "59f90caadd1b176f02eddcda"
+patch = {"foo" => "newbar"}
+e.update_one(id, patch)
+
+=> {"id"=>"59f90caadd1b176f02eddcda", "uri"=>"127.0.0.1:8080/api/v1/entity/59f90caadd1b176f02eddcda", "diff"=>{"_id"=>"59f90caadd1b176f02eddcda", "_rev"=>0, "_type"=>"node", "foo"=>"abc"}}
+```
+
+Delete entities
+```
+query = "foo=bar"
+e.delete(query)
+```
+
+Delete a single entity
+```
+id = "abc"
+e.delete_one(id)
+=> {"_id" => "abc", "foo" => "bar"}
+```
+
+List the labels for an entity
+```
+id = "abc"
+e.labels(id)
+=> ["foo"]
+```
+
+Development
+------
+Run the tests
+```
+bundle exec rake spec
+```
+
+## License
+
+Copyright (c) 2017 Square Inc. Distributed under the Apache 2.0 License.
+See LICENSE file for further details.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rspec/core/rake_task'
+
+desc "run specs"
+RSpec::Core::RakeTask.new

data/etre-client.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'etre-client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'etre-client'
+  spec.version       = Etre::Client::VERSION
+  spec.version       = '0.8.0'
+  spec.license       = 'Apache-2.0'
+  spec.authors       = ['Michael Finch']
+  spec.email         = ['mfinch@squareup.com']
+  spec.summary       = 'Client gem for interacting with Etre'
+  spec.homepage      = 'https://github.com/square/etre-client-ruby'
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'json'
+  spec.add_runtime_dependency 'rest-client', '~> 2.0'
+
+  spec.add_development_dependency 'rake', '~> 12.2', '>= 12.2.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/etre-client.rb

@@ -0,0 +1,264 @@
+require 'etre-client/errors'
+require 'rest-client'
+require 'json'
+
+module Etre
+  class Client
+    attr_reader :entity_type, :url
+
+    API_ROOT = "/api/v1"
+    META_LABEL_ID = "_id"
+    META_LABEL_TYPE = "_type"
+
+    def initialize(entity_type:, url:, ssl_cert: nil, ssl_key: nil, ssl_ca: nil, insecure: true)
+      @entity_type = entity_type
+      @url = url
+
+      @ssl_cert = ssl_cert
+      @ssl_key = ssl_key
+      @ssl_ca = ssl_ca
+      @insecure = insecure
+    end
+
+    # query returns an array of entities that satisfy a query.
+    def query(query, filter = nil)
+      if query.nil? || query.empty?
+        raise QueryNotProvided
+      end
+
+      # @todo: translate filter to query params
+
+      # Do the normal GET /entities?query unless the query is ~2k characters
+      # becuase that brings the entire URL length close to the max supported
+      # limit across most HTTP servers. In that case, switch to alternate
+      # endpoint to POST the long query.
+      if query.length < 2000
+        # Always escape the query.
+        query = CGI::escape(query)
+
+        resp = etre_get("/entities/#{@entity_type}?query=#{query}")
+      else
+        # DO NOT ESCAPE THE QUERY! It's not sent via URL, so no escaping needed.
+        resp = etre_post("/query/#{@entity_type}", query)
+      end
+
+      if resp.code != 200
+        raise UnexpectedResponseCode, "expected 200, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    # insert inserts an array of entities.
+    def insert(entities)
+      if entities.nil? || !entities.any?
+        raise EntityNotProvided
+      end
+
+      entities.each do |e|
+        if e.key?(META_LABEL_ID)
+          raise EntityIdSet, "entity: #{e}"
+        end
+
+        if e.key?(META_LABEL_TYPE) && e[META_LABEL_TYPE] != @entity_type
+          raise EntityTypeMismatch, "only valid type is '#{@entity_type}', but " +
+            "entity has type '#{e[META_LABEL_TYPE]}'"
+        end
+      end
+
+      resp = etre_post("/entities/#{@entity_type}", entities)
+      if ![200, 201].include?(resp.code)
+        raise UnexpectedResponseCode, "expected 200 or 201, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    # update updates entities with the given patch that satisfy the given query.
+    def update(query, patch)
+      if query.nil? || query.empty?
+        raise QueryNotProvided
+      end
+
+      # Always escape the query.
+      query = CGI::escape(query)
+
+      if patch.nil? || !patch.any?
+        raise PatchNotProvided
+      end
+
+      if patch.key?(META_LABEL_ID)
+        raise PatchIdSet, "patch: #{patch}"
+      end
+
+      if patch.key?(META_LABEL_TYPE) && patch[META_LABEL_TYPE] != @entity_type
+        raise EntityTypeMismatch, "only valid type is '#{@entity_type}', but " +
+          "patch has type '#{patch[META_LABEL_TYPE]}'"
+      end
+
+      resp = etre_put("/entities/#{@entity_type}?query=#{query}", patch)
+      if ![200, 201].include?(resp.code)
+        raise UnexpectedResponseCode, "expected 200 or 201, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    # update_one updates the given entity id with the provided patch.
+    def update_one(id, patch)
+      if id.nil? || id.empty?
+        raise IdNotProvided
+      end
+
+      if patch.nil? || !patch.any?
+        raise PatchNotProvided
+      end
+
+      if patch.key?(META_LABEL_ID)
+        raise PatchIdSet, "patch: #{patch}"
+      end
+
+      if patch.key?(META_LABEL_TYPE) && patch[META_LABEL_TYPE] != @entity_type
+        raise EntityTypeMismatch, "only valid type is '#{@entity_type}', but " +
+          "patch has type '#{patch[META_LABEL_TYPE]}'"
+      end
+
+      resp = etre_put("/entity/#{@entity_type}/#{id}", patch)
+      if ![200, 201].include?(resp.code)
+        raise UnexpectedResponseCode, "expected 200 or 201, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    # delete deletes the entities that satisfy the given query.
+    def delete(query)
+      if query.nil? || query.empty?
+        raise QueryNotProvided
+      end
+
+      # Always escape the query.
+      query = CGI::escape(query)
+
+      resp = etre_delete("/entities/#{@entity_type}?query=#{query}")
+      if resp.code != 200
+        raise UnexpectedResponseCode, "expected 200, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    # delete_one deletes the entity with the given id.
+    def delete_one(id)
+      if id.nil? || id.empty?
+        raise IdNotProvided
+      end
+
+      resp = etre_delete("/entity/#{@entity_type}/#{id}")
+      if resp.code != 200
+        raise UnexpectedResponseCode, "expected 200, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    # labels returns an array of labels for the given entity id.
+    def labels(id)
+      if id.nil? || id.empty?
+        raise IdNotProvided
+      end
+
+      resp = etre_get("/entity/#{@entity_type}/#{id}/labels")
+
+      if resp.code != 200
+        raise UnexpectedResponseCode, "expected 200, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    # delete_label deletes the given label on the provided entity id.
+    def delete_label(id, label)
+      if id.nil? || id.empty?
+        raise IdNotProvided
+      end
+
+      if label.nil? || label.empty?
+        raise LabelNotSet
+      end
+
+      resp = etre_delete("/entity/#{@entity_type}/#{id}/labels/#{label}")
+      if resp.code != 200
+        raise UnexpectedResponseCode, "expected 200, got #{resp.code}"
+      end
+
+      return JSON.parse(resp.body)
+    end
+
+    private
+
+    def etre_get(route)
+      resource_for_route(route).get(
+        get_headers,
+      )
+    end
+
+    def etre_post(route, params = nil)
+      resource_for_route(route).post(
+        params.to_json,
+        post_headers,
+      )
+    end
+
+    def etre_put(route, params = nil)
+      resource_for_route(route).put(
+        params.to_json,
+        put_headers,
+      )
+    end
+
+    def etre_delete(route)
+      resource_for_route(route).delete(
+        delete_headers,
+      )
+    end
+
+    def get_headers
+      {:accept => 'application/json'}
+    end
+
+    def post_headers
+      get_headers.merge!(:content_type => 'application/json')
+    end
+
+    def put_headers
+      post_headers
+    end
+
+    def delete_headers
+      get_headers
+    end
+
+    def resource_for_route(route)
+      opts = {}
+      opts.merge!(ssl_options) unless @insecure
+      RestClient::Resource.new(
+        @url + API_ROOT + route,
+        opts
+      )
+    end
+
+    def ssl_options
+      {
+        :ssl_client_cert => OpenSSL::X509::Certificate.new(File.read(@ssl_cert)),
+        :ssl_client_key  => OpenSSL::PKey::RSA.new(File.read(@ssl_key)),
+        :ssl_ca_file     => @ssl_ca,
+        :verify_ssl      => OpenSSL::SSL::VERIFY_PEER,
+      }
+    end
+
+    def parse_response(response)
+      JSON.parse(response)
+    end
+  end
+end

data/lib/etre-client/errors.rb

@@ -0,0 +1,13 @@
+module Etre
+  class Client
+    class EntityIdSet < StandardError; end
+    class EntityNotProvided < StandardError; end
+    class EntityTypeMismatch < StandardError; end
+    class IdNotProvided < StandardError; end
+    class LabelNotSet < StandardError; end
+    class PatchIdSet < StandardError; end
+    class PatchNotProvided < StandardError; end
+    class QueryNotProvided < StandardError; end
+    class UnexpectedResponseCode < StandardError; end
+  end
+end

data/lib/etre-client/version.rb

@@ -0,0 +1,5 @@
+module Etre
+  class Client
+    VERSION = "0.8.0"
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,328 @@
+require 'etre-client'
+require 'ostruct'
+
+describe Etre::Client do
+  let(:etre_client) { Etre::Client.new(entity_type: "node", url: "http://localhost:3000", insecure: true) }
+  let(:get_headers) { {:accept => "application/json"} }
+  let(:post_headers) { get_headers.merge({:content_type => "application/json"}) }
+  let(:put_headers) { post_headers }
+  let(:delete_headers) { get_headers }
+  let(:migration_id) { 3 }
+  let(:cluster) { "cluster-001" }
+  let(:entity1) { {"_id" => "abc", "foo" => "bar"} }
+  let(:entity2) { {"oof" => "rab"} }
+  let(:entity3) { {"blah" => "slug"} }
+  let(:entity4) { {"_type" => "host", "a" => "b"} }
+  let(:response_double) { instance_double(RestClient::Response) }
+  let(:resource_double) { instance_double(RestClient::Resource) }
+
+  describe '#query' do
+    it "makes GET request when query is short" do
+      q = "foo=bar"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entities/#{etre_client.entity_type}?query=#{CGI::escape(q)}"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return([entity1].to_json)
+      expect(resource_double).to receive(:get).with(get_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.query(q)).to eq([entity1])
+    end
+
+    it "makes POST request when query is too long" do
+      q = "foo=bar," * 300
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/query/#{etre_client.entity_type}"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return([entity1].to_json)
+      expect(resource_double).to receive(:post).with(q.to_json, post_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.query(q)).to eq([entity1])
+    end
+
+    it "raises if query is empty" do
+      q = ""
+
+      expect{etre_client.query(q)}.to raise_error(Etre::Client::QueryNotProvided)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      q = "foo=bar"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entities/#{etre_client.entity_type}?query=#{CGI::escape(q)}"
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:get).with(get_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect{etre_client.query(q)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+
+  describe "#insert" do
+    before :each do
+      @path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entities/#{etre_client.entity_type}"
+    end
+
+    it "inserts entities" do
+      entities = [entity2, entity3]
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return(entities.to_json)
+      expect(resource_double).to receive(:post).with(entities.to_json, post_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(@path, {}).and_return(resource_double)
+      expect(etre_client.insert(entities)).to eq(entities)
+    end
+
+    it "raises if an entity has _id set" do
+      entities = [entity1, entity2]
+
+      expect{etre_client.insert(entities)}.to raise_error(Etre::Client::EntityIdSet)
+    end
+
+    it "raises if an entity has the wrong _type set" do
+      entities = [entity2, entity4]
+
+      expect{etre_client.insert(entities)}.to raise_error(Etre::Client::EntityTypeMismatch)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      entities = [entity2, entity3]
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:post).with(entities.to_json, post_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(@path, {}).and_return(resource_double)
+      expect{etre_client.insert(entities)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+
+  describe "#update" do
+    it "updates entities" do
+      query = "foo=bar"
+      patch = {"foo" => "new"}
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entities/#{etre_client.entity_type}?query=#{CGI::escape(query)}"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return({}.to_json)
+      expect(resource_double).to receive(:put).with(patch.to_json, put_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.update(query, patch)).to eq({})
+    end
+
+    it "raises if query is empty" do
+      query = ""
+      patch = {"foo" => "new"}
+
+      expect{etre_client.update(query, patch)}.to raise_error(Etre::Client::QueryNotProvided)
+    end
+
+    it "raises if patch is empty" do
+      query = "foo=bar"
+      patch = {}
+
+      expect{etre_client.update(query, patch)}.to raise_error(Etre::Client::PatchNotProvided)
+    end
+
+    it "raises if _id is set in patch" do
+      query = "foo=bar"
+      patch = {"_id" => "abc"}
+
+      expect{etre_client.update(query, patch)}.to raise_error(Etre::Client::PatchIdSet)
+    end
+
+    it "raises if patch has the wrong _type set" do
+      query = "foo=bar"
+      patch = {"_type" => "host"}
+
+      expect{etre_client.update(query, patch)}.to raise_error(Etre::Client::EntityTypeMismatch)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      query = "foo=bar"
+      patch = {"foo" => "new"}
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entities/#{etre_client.entity_type}?query=#{CGI::escape(query)}"
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:put).with(patch.to_json, put_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect{etre_client.update(query, patch)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+
+  describe "#update_one" do
+    it "updates an entity" do
+      id = "abc"
+      patch = {"foo" => "new"}
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return({}.to_json)
+      expect(resource_double).to receive(:put).with(patch.to_json, put_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.update_one(id, patch)).to eq({})
+    end
+
+    it "raises if id is empty" do
+      id = ""
+      patch = {"foo" => "new"}
+
+      expect{etre_client.update_one(id, patch)}.to raise_error(Etre::Client::IdNotProvided)
+    end
+
+    it "raises if patch is empty" do
+      id = "abc"
+      patch = {}
+
+      expect{etre_client.update_one(id, patch)}.to raise_error(Etre::Client::PatchNotProvided)
+    end
+
+    it "raises if _id is set in patch" do
+      id = "abc"
+      patch = {"_id" => "abc"}
+
+      expect{etre_client.update_one(id, patch)}.to raise_error(Etre::Client::PatchIdSet)
+    end
+
+    it "raises if patch has the wrong _type set" do
+      id = "abc"
+      patch = {"_type" => "host"}
+
+      expect{etre_client.update_one(id, patch)}.to raise_error(Etre::Client::EntityTypeMismatch)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      id = "abc"
+      patch = {"foo" => "new"}
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}"
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:put).with(patch.to_json, put_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect{etre_client.update_one(id, patch)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+
+  describe "#delete" do
+    it "deletes entities" do
+      query = "foo=bar"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entities/#{etre_client.entity_type}?query=#{CGI::escape(query)}"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return({}.to_json)
+      expect(resource_double).to receive(:delete).with(delete_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.delete(query)).to eq({})
+    end
+
+    it "raises if query is empty" do
+      query = ""
+
+      expect{etre_client.delete(query)}.to raise_error(Etre::Client::QueryNotProvided)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      query = "foo=bar"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entities/#{etre_client.entity_type}?query=#{CGI::escape(query)}"
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:delete).with(delete_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect{etre_client.delete(query)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+
+  describe "#delete_one" do
+    it "deletes an entity" do
+      id = "abc"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return({}.to_json)
+      expect(resource_double).to receive(:delete).with(delete_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.delete_one(id)).to eq({})
+    end
+
+    it "raises if id is empty" do
+      id = ""
+
+      expect{etre_client.delete_one(id)}.to raise_error(Etre::Client::IdNotProvided)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      id = "abc"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}"
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:delete).with(delete_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect{etre_client.delete_one(id)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+
+  describe "#labels" do
+    it "lists the lables for an entity" do
+      id = "abc"
+      labels = ["foo1", "foo2"]
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}/labels"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return(labels.to_json)
+      expect(resource_double).to receive(:get).with(get_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.labels(id)).to eq(labels)
+    end
+
+    it "raises if id is empty" do
+      id = ""
+
+      expect{etre_client.labels(id)}.to raise_error(Etre::Client::IdNotProvided)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      id = "abc"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}/labels"
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:get).with(get_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect{etre_client.labels(id)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+
+  describe "#delete_label" do
+    it "deletes the label on an entity" do
+      id = "abc"
+      label = "foo"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}/labels/#{label}"
+
+      expect(response_double).to receive(:code).and_return(200)
+      expect(response_double).to receive(:body).and_return({}.to_json)
+      expect(resource_double).to receive(:delete).with(delete_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect(etre_client.delete_label(id, label)).to eq({})
+    end
+
+    it "raises if id is empty" do
+      id = ""
+      label = "foo"
+
+      expect{etre_client.delete_label(id, label)}.to raise_error(Etre::Client::IdNotProvided)
+    end
+
+    it "raises if label is empty" do
+      id = ""
+      label = ""
+
+      expect{etre_client.delete_label(id, label)}.to raise_error(Etre::Client::IdNotProvided)
+    end
+
+    it "raises if it gets an unexpected response code" do
+      id = "abc"
+      label = "foo"
+      path = "#{etre_client.url}#{Etre::Client::API_ROOT}/entity/#{etre_client.entity_type}/#{id}/labels/#{label}"
+
+      expect(response_double).to receive(:code).twice.and_return(400)
+      expect(resource_double).to receive(:delete).with(delete_headers).and_return(response_double)
+      expect(RestClient::Resource).to receive(:new).with(path, {}).and_return(resource_double)
+      expect{etre_client.delete_label(id, label)}.to raise_error(Etre::Client::UnexpectedResponseCode)
+    end
+  end
+end

data/spec/unit_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: etre-client
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Michael Finch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- mfinch@squareup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- etre-client.gemspec
+- lib/etre-client.rb
+- lib/etre-client/errors.rb
+- lib/etre-client/version.rb
+- spec/client_spec.rb
+- spec/unit_helper.rb
+homepage: https://github.com/square/etre-client-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Client gem for interacting with Etre
+test_files:
+- spec/client_spec.rb
+- spec/unit_helper.rb