apigee_cli 0.0.1

data/lib/apigee_cli/config_set.rb

@@ -0,0 +1,109 @@
+module ApigeeCli
+  class ConfigSet < Base
+
+    MAP_KEY             = 'keyValueMap'
+    ENTRY_KEY           = 'entry'
+    DEFAULT_CONFIG_NAME = 'configuration'
+
+    def base_url
+      "https://api.enterprise.apigee.com/v1/o/#{org}/environments/#{environment}/keyvaluemaps"
+    end
+
+    def list_configs
+      # We need the expand: true option to get an expanded view of the KeyValueMaps
+      response = get(base_url, expand: true)
+      if response.status != 200
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def read_config(config_name)
+      url = [base_url, config_name].join('/')
+      response = get(url)
+      if response.status != 200
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def write_config(config_name, data)
+      body = {
+        name: config_name,
+        entry: data
+      }
+      response = post(base_url, body)
+      if response.status != 201
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def update_config(config_name, data)
+      url = [base_url, config_name].join('/')
+      body = {
+        name: config_name,
+        entry: data
+      }
+      response = put(url, body)
+      if response.status != 200
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def add_config(config_name, data, overwrite)
+      changed_keys = []
+
+      begin
+        response = Hashie::Mash.new(read_config(config_name))
+        if overwrite
+          result = :overwritten
+        else
+          orig_keys = response[ENTRY_KEY].map(&:name)
+          data.reject! { |pair| orig_keys.include?(pair['name']) }
+
+          result = :existing
+        end
+
+        update_config(config_name, data)
+      rescue RuntimeError => e
+        if e.message.include?('keyvaluemap_doesnt_exist')
+          result = :new
+          write_config(config_name, data)
+        else
+          changed_keys = [e.to_s]
+          result = :error
+        end
+      end
+
+      changed_keys = data.map(&:name)
+      [result, changed_keys]
+    end
+
+    def remove_config(config_name)
+      url = [base_url, config_name].join('/')
+      response = delete(url)
+      if response.status != 200
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def remove_entry(config_name, entry_name)
+      url = [base_url, config_name, 'entries', entry_name].join('/')
+
+      response = delete(url)
+      if response.status != 200
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/apigee_cli/configuration.rb

@@ -0,0 +1,42 @@
+module ApigeeCli
+  class << self
+    def configuration
+      @configuration ||= ApigeeCli::Configuration.new
+    end
+  end
+
+  class Configuration
+    def apigeerc_config
+      begin
+        @apigeerc_config = YAML.load_file("#{ENV['HOME']}/.apigeerc")
+      rescue
+        raise "Error loading .apigeerc file"
+      end
+      @apigeerc_config.merge! local_apigeerc_config
+      @apigeerc_config
+    end
+
+    def username
+      raise 'Not Configured' if apigeerc_config['username'].nil?
+      apigeerc_config['username']
+    end
+
+    def password
+      raise 'Not Configured' if apigeerc_config['password'].nil?
+      apigeerc_config['password']
+    end
+
+    def org
+      raise 'Not Configured' if apigeerc_config['org'].nil?
+      apigeerc_config['org']
+    end
+
+    def local_apigeerc_config
+      File.exists?("./.apigeerc") ? YAML.load_file("./.apigeerc") : {}
+    end
+
+    def method_missing(sym, *args, &block)
+      apigeerc_config[sym.to_s]
+    end
+  end
+end

data/lib/apigee_cli/resource_file.rb

@@ -0,0 +1,64 @@
+module ApigeeCli
+  class ResourceFile < Base
+
+    RESOURCE_FILE_KEY = 'resourceFile'
+    DEFAULT_RESOURCE_TYPE = 'jsc'
+
+    def base_url
+      "https://api.enterprise.apigee.com/v1/organizations/#{org}/resourcefiles"
+    end
+
+    def all
+      response = get(base_url)
+      if response.status != 200
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def read(name, resource_type)
+      url = [base_url,resource_type,name].join('/')
+      response = get(url)
+      if response.status == 404
+        nil
+      elsif response.status != 200
+        response_error(response)
+      else
+        response.body
+      end
+    end
+
+    def create(name, resource_type, file)
+      url = "#{base_url}?name=#{name}&type=#{resource_type}"
+      response = upload_file(url, file)
+      if response.status != 201
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def remove(name, resource_type)
+      url = [base_url,resource_type,name].join('/')
+      response = delete(url)
+      if response.status != 200
+        response_error(response)
+      else
+        JSON.parse(response.body)
+      end
+    end
+
+    def upload(name, resource_type, file)
+      if read(name, resource_type)
+        result = :overwritten
+        remove(name, resource_type)
+      else
+        result = :new_file
+      end
+      create(name, resource_type, file)
+      result
+    end
+
+  end
+end

data/lib/apigee_cli/version.rb

@@ -0,0 +1,3 @@
+module ApigeeCli
+  VERSION = "0.0.1"
+end

data/lib/apigee_cli.rb

@@ -0,0 +1,18 @@
+require 'httparty'
+require 'hashie'
+require 'git'
+
+begin
+  require 'pry'
+rescue Gem::LoadError
+end
+
+require 'apigee_cli/configuration'
+require 'apigee_cli/base'
+require 'apigee_cli/version'
+
+require 'apigee_cli/config_set'
+require 'apigee_cli/resource_file'
+
+module ApigeeCli
+end

data/spec/base_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'apigee_cli/base'
+
+describe ApigeeCli::Base do
+  before do
+    module ApigeeCli
+      class Foo < Base
+        def base_url
+          "http://foos.com"
+        end
+      end
+    end
+  end
+
+  let(:foo) { ApigeeCli::Foo.new }
+  let(:username) { ApigeeCli.configuration.username }
+  let(:password) { ApigeeCli.configuration.password }
+  let(:file) { Rack::Test::UploadedFile.new('spec/fixtures/test.txt', 'text/plain') }
+
+  describe '#get' do
+    it 'performs a get via Faraday::Connection with basic auth' do
+      expect_any_instance_of(Faraday::Connection).to receive(:basic_auth).with(username, password)
+      expect_any_instance_of(Faraday::Connection).to receive :get
+
+      foo.get(foo.base_url)
+    end
+  end
+
+  describe '#upload_file' do
+    it 'performs a post via Faraday::Connection with basic auth' do
+      stub_request(:post, "http://example_user:password@foos.com/")
+         .with(:body => "\"{\\\"leslie\\\":\\\"knope\\\"}\"",
+              :headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type'=>'application/json', 'User-Agent'=>'Faraday v0.9.1'})
+         .to_return(:status => 200, :body => "", :headers => {})
+      expect_any_instance_of(Faraday::Connection).to receive(:basic_auth).with(username, password)
+      expect_any_instance_of(Faraday::Connection).to receive :post
+
+      foo.upload_file(foo.base_url, file)
+    end
+
+    it 'appends the right headers to the request' do
+      stub_request(:post, "http://example_user:password@foos.com/")
+         .with(:body => "This is a test.\n",
+              :headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Length'=>'16', 'Content-Type'=>'application/octet-stream', 'User-Agent'=>'Faraday v0.9.1'})
+         .to_return(:status => 200, :body => "", :headers => {})
+
+      result = foo.upload_file(foo.base_url, file)
+      request_headers = result.env.request_headers
+
+      expect(request_headers['Content-Type']).to eq 'application/octet-stream'
+      expect(request_headers['Content-Length']).to eq File.size(file).to_s
+      # TODO: check request body? it is currently an empty string...
+    end
+  end
+
+  describe '#post' do
+    it 'performs a post via Faraday::Connection with basic auth' do
+      expect_any_instance_of(Faraday::Connection).to receive(:basic_auth).with(username, password)
+      expect_any_instance_of(Faraday::Connection).to receive :post
+
+      foo.post(foo.base_url, { leslie: 'knope' }.to_json)
+    end
+
+    it 'appends the right headers to the request' do
+      result = foo.post(foo.base_url, { leslie: 'knope' }.to_json)
+      request_headers = result.env.request_headers
+
+      expect(request_headers['Content-Type']).to eq 'application/json'
+    end
+  end
+
+  describe '#delete' do
+    it 'performs a delete via Faraday::Connection with basic auth' do
+      expect_any_instance_of(Faraday::Connection).to receive(:basic_auth).with(username, password)
+      expect_any_instance_of(Faraday::Connection).to receive :delete
+
+      foo.delete(foo.base_url)
+    end
+
+    # TODO: should delete be doing more?
+  end
+end

data/spec/cli/app_config_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'apigee_cli/cli/app_config'
+
+describe AppConfig do
+  describe 'apigee config list' do
+    it 'prints all the key value maps' do
+      app_config = AppConfig.new([])
+      app_config.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:list_configs).and_return({
+        "keyValueMap" => [
+          { "entry" => [ { "name" => "key_one", "value" => "value_one" },
+                         { "name" => "key_two", "value" => "value_two" }
+                       ],
+            "name" => "configuration"
+          }
+        ]
+      })
+
+      app_config.invoke(:list)
+
+      expect(app_config.shell.printed).to eq [
+        "Environment: test, Config Name: configuration",
+        "  key_one: value_one",
+        "  key_two: value_two"
+      ]
+    end
+
+    it 'prints the key value pairs for --config_name' do
+      app_config = AppConfig.new([], config_name: 'teehee')
+      app_config.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:read_config).with('teehee').and_return({
+        "entry" => [ { "name" => "key_a", "value" => "value_a" },
+                     { "name" => "key_b", "value" => "value_b" }
+                   ],
+        "name" => "teehee"
+      })
+
+      app_config.invoke(:list)
+
+      expect(app_config.shell.printed).to eq [
+        "Environment: test, Config Name: teehee",
+        "  key_a: value_a",
+        "  key_b: value_b"
+      ]
+    end
+
+    specify 'when config does not exist on Apigee Server, an error is rendered' do
+      app_config = AppConfig.new([])
+      app_config.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:list_configs).and_raise("Map does not exist")
+
+      app_config.invoke(:list)
+
+      expect(app_config.shell.printed).to eq ["Map does not exist"]
+    end
+  end
+
+  describe 'apigee config push' do
+    let(:config_name) { 'test_config' }
+
+    before do
+      allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:read_config).with(config_name).and_return({
+        "entry" => [ { "name" => "key_a", "value" => "value_a" },
+                     { "name" => "key_b", "value" => "value_b" }
+                   ],
+        "name" => config_name
+      })
+    end
+
+    context 'when key value map with --config_name doesn\'t exist' do
+      it 'creates a new key value map' do
+        app_config = AppConfig.new([], config_name: config_name)
+        app_config.shell = ShellRecorder.new
+        allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:add_config).and_return([
+          :new, [:key_one]
+        ])
+
+        app_config.invoke(:push)
+
+        expect(app_config.shell.printed).to include "Creating new config for [#{config_name}] in [test] environment"
+      end
+    end
+
+    context 'when key value map with --config_name exists' do
+      context 'when a key value pair exists' do
+        it 'gets replaced with new key value pair if --overwrite=true' do
+          app_config = AppConfig.new([], config_name: config_name, overwrite: true)
+          app_config.shell = ShellRecorder.new
+          allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:add_config).and_return([
+            :overwritten, [:key_a]
+          ])
+
+          app_config.invoke(:push, ["key_a=new_value_a"])
+
+          expect(app_config.shell.printed).to include "Overwriting existing config [#{config_name}] in [test] environment"
+        end
+      end
+
+      context 'when a key value pair doesn\'t exist' do
+        it 'gets added to the key value map' do
+          app_config = AppConfig.new([], config_name: config_name)
+          app_config.shell = ShellRecorder.new
+          allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:add_config).and_return([
+            :existing, [:key_one]
+          ])
+
+          app_config.invoke(:push, ["key_one=value_one"])
+
+          expect(app_config.shell.printed).to include "Adding new keys [:key_one] to config [#{config_name}] in [test] environment"
+        end
+      end
+    end
+
+    it 'renders an error when there was an error trying to update config' do
+      app_config = AppConfig.new([], config_name: config_name)
+      app_config.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:add_config).and_return([
+        :error, ["There was an error"]
+      ])
+
+      expect {
+        app_config.invoke(:push, ["key_a=new_value"])
+      }.to raise_error SystemExit
+
+      expect(app_config.shell.printed).to include "Error [There was an error] pushing config for [test_config] to [test] environment"
+    end
+  end
+
+  describe 'apigee config delete' do
+    let(:config_name) { ApigeeCli::ConfigSet::DEFAULT_CONFIG_NAME }
+    before do
+      allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:list_configs).and_return({
+        "keyValueMap" => [
+          { "entry" => [ { "name" => "key_one", "value" => "value_one" },
+                         { "name" => "key_two", "value" => "value_two" }
+                       ],
+            "name" => "#{config_name}"
+          }
+        ]
+      })
+    end
+
+    context 'when user gives permission' do
+      it 'deletes --config_name=configuration key value map by default' do
+        app_config = AppConfig.new([])
+        app_config.shell = ShellRecorder.new
+        allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:remove_config).with(config_name).and_return({
+          "entry" => [],
+          "name"  => "#{config_name}"
+        })
+        allow(app_config.shell).to receive(:yes?).and_return(true)
+
+        app_config.invoke(:delete)
+
+        expect(app_config.shell.printed).to include "Config [#{config_name}] has been deleted from [test] environment"
+      end
+
+      it 'deletes --entry_name entry from --config_name key value map' do
+        entry_name = "key_one"
+        app_config = AppConfig.new([], entry_name: entry_name)
+        app_config.shell = ShellRecorder.new
+        allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:remove_entry).with(config_name, entry_name).and_return({
+          "name"  => "key_one",
+          "value" => "value_one"
+        })
+        allow(app_config.shell).to receive(:yes?).and_return(true)
+
+        app_config.invoke(:delete)
+
+        expect(app_config.shell.printed).to include "Entry [key_one] has been deleted from [configuration] in [test] environment"
+      end
+
+      it 'renders an error when there was an error updating a config on the server' do
+        app_config = AppConfig.new([])
+        app_config.shell = ShellRecorder.new
+        allow_any_instance_of(ApigeeCli::ConfigSet).to receive(:remove_config).and_raise("Error deleting #{config_name}")
+        allow(app_config.shell).to receive(:yes?).and_return(true)
+
+        app_config.invoke(:delete)
+
+        expect(app_config.shell.printed).to include "Error deleting #{config_name}"
+      end
+    end
+
+    context 'when user doesn\'t give permission' do
+      it 'doesn\'t delete the --config_name key value map' do
+        app_config = AppConfig.new([])
+        app_config.shell = ShellRecorder.new
+        allow(app_config.shell).to receive(:yes?).and_return(false)
+
+        expect_any_instance_of(ApigeeCli::ConfigSet).to_not receive :remove_config
+
+        expect {
+          app_config.invoke(:delete)
+        }.to raise_error SystemExit
+      end
+
+      it 'doesn\'t delete the --entry_name entry from --config_name key value map' do
+      end
+    end
+  end
+end

data/spec/cli/resource_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'apigee_cli/cli/resource'
+
+describe Resource do
+  describe 'apigee resource list' do
+    it 'prints the names of the files, by default' do
+      resource = Resource.new([])
+      resource.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ResourceFile).to receive(:all).and_return({
+        "resourceFile" => [
+          { "name" => "lodash.js", "type" => "jsc" },
+          { "name" => "honeybadger.js", "type" => "jsc" }
+        ]
+      })
+
+      resource.invoke(:list)
+
+      expect(resource.shell.printed).to eq [
+        "Resource files for bellycard",
+        "  jsc file - lodash.js",
+        "  jsc file - honeybadger.js"
+      ]
+    end
+
+    it 'prints the content of the file for the requested --name' do
+      resource = Resource.new([], name: 'test.js')
+      resource.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ResourceFile).to receive(:read)
+        .with('test.js', 'jsc')
+        .and_return("Hello World")
+
+      resource.invoke(:list)
+
+      expect(resource.shell.printed).to eq ["Hello World"]
+    end
+  end
+
+  describe 'apigee resource upload' do
+    it 'requires the --folder from which to upload files' do
+      resource = Resource.new([])
+
+      expect {
+        resource.invoke(:upload)
+      }.to raise_error Thor::RequiredArgumentMissingError
+    end
+
+    it 'uploads only .js files in --folder to the Apigee server' do
+      resource = Resource.new([], folder: File.expand_path('../fixtures', __dir__))
+      resource.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ResourceFile).to receive(:upload).and_return(:new_file)
+
+      resource.invoke(:upload)
+
+      expect(resource.shell.printed).to_not include 'Creating resource for test.txt'
+      expect(resource.shell.printed).to eq [
+        "Creating resource for test.js",
+        "Creating resource for test2.js"
+      ]
+    end
+
+    specify 'when the file exists, it deletes it before uploading' do
+      resource = Resource.new([], folder: File.expand_path('../fixtures', __dir__))
+      resource.shell = ShellRecorder.new
+      allow_any_instance_of(ApigeeCli::ResourceFile).to receive(:upload).and_return(:overwritten)
+
+      resource.invoke(:upload)
+
+      expect(resource.shell.printed).to eq [
+        "Deleting current resource for test.js",
+        "Deleting current resource for test2.js"
+      ]
+    end
+  end
+
+  describe 'apigee resource delete' do
+    it 'requires the --name of the file to delete' do
+      resource = Resource.new([])
+
+      expect {
+        resource.invoke(:delete)
+      }.to raise_error Thor::RequiredArgumentMissingError
+    end
+
+    context 'when user gives permission to delete the file' do
+      before do
+        allow_any_instance_of(ShellRecorder).to receive(:yes?).and_return true
+      end
+
+      it 'deletes the file if it exists' do
+        resource = Resource.new([], name: 'test3.js')
+        resource.shell = ShellRecorder.new
+        allow_any_instance_of(ApigeeCli::ResourceFile).to receive(:remove)
+          .with('test3.js', 'jsc')
+          .and_return("Deleted")
+
+        resource.invoke(:delete)
+
+        expect(resource.shell.printed).to eq [
+          "Deleting current resource for test3.js"
+        ]
+      end
+
+      it 'renders an error when the file doesn\'t exist on the server' do
+        resource = Resource.new([], name: 'test3.js')
+        resource.shell = ShellRecorder.new
+        allow_any_instance_of(ApigeeCli::ResourceFile).to receive(:remove).and_raise("Resource already exists")
+
+        expect {
+          resource.invoke(:delete)
+        }.to raise_error SystemExit
+
+        expect(resource.shell.printed).to include "Resource already exists"
+      end
+    end
+
+    context 'when user doesn\'t give permission to delete the file' do
+      before do
+        allow_any_instance_of(ShellRecorder).to receive(:yes?).and_return false
+      end
+
+      it 'doesn\'t delete the file' do
+        resource = Resource.new([], name: 'test3.js')
+        resource.shell = ShellRecorder.new
+
+        expect_any_instance_of(ApigeeCli::ResourceFile).to_not receive(:remove)
+
+        expect {
+          resource.invoke(:delete)
+        }.to raise_error SystemExit
+      end
+    end
+  end
+end