kong_schema 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 413c7b7271ed7feca20d06caeaf0bd671bf5d253
-  data.tar.gz: b79a0818ae360b7df3e7e9dc6a3ffc84398d3e05
+  metadata.gz: a77eb790a5c2e9bc9041918244f463890a598b48
+  data.tar.gz: 76815d46d5c50a3d6cc01aee03d13b6b0f870ee0
 SHA512:
-  metadata.gz: fab914455b8b170f43ff70537e9604ac8e4489b6264356277257ddaff95f6df25c8cc36cae2107b5fd60987cb9a9bb4455e06319c97e67ea8824a35ce567b194
-  data.tar.gz: e1861af086a278bd9257469dccc314cc26211814bac1db35d8800171ad480a234b539c4424e25c40ac86ca13b081171577882c47f42dedee5c236ec091992726
+  metadata.gz: 8186d7fb699bf6ae80f6534fc66aeedc735dcef9594f063d498361d02375a152fb0efb9e33080ee025928333c9cb1662d8b91ef76647a378fd341d3b9d440edf
+  data.tar.gz: 8522830249a8c888dd7ab6dcc5712921e80c8fedc13ffb152f250574e8d405fa94d7da9cea8760348376696e0a3b58fefb3c3a02a91b6c720260a0d7ff421817

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.3.0
+
+- Added support for Kong::Plugin objects.
+- Renamed the CLI command `kong_schema reset` to `kong_schema down` for
+  consistency.
+- All CLI commands now accept `-c` or `--config` to point to the config file in
+  place of the first argument. This makes it consistent with Kong's binaries
+  for user convenience.
+
 ## 1.2.0
 
 - Added a new CLI command: `kong_schema reset` for wiping out the Kong database

data/README.md

@@ -39,7 +39,7 @@ Run `kong_schema --help` to see the available commands.
 kong_schema up [path/to/config.yml]
 
 # reset configuration
-kong_schema reset [path/to/config.yml]
+kong_schema down [path/to/config.yml]
 ```
 
 ## Example
@@ -73,8 +73,9 @@ Then if we run the following command:
 kong_schema up config/kong.yml
 ```
 
-kong_schema will read the directives found under the `kong` dictionary and
-prompt you with a list of changes it will apply to Kong through the REST API.
+kong_schema will read the directives ("schema") found in the `kong` dictionary
+and prompt you with a list of changes it will apply to Kong through the REST
+API.
 
 ```shell
 +-----------------+------------------------------------------------+
@@ -160,11 +161,29 @@ Nice and easy!
 
 ## Configuration
 
+As mentioned before, you can either use YAML or JSON to write your
+configuration files. YAML tends to be more readable and easier to edit.
+`kong_schema` will know which parser to use based on the file extension; they
+have to end with either `.yml` or `.json` respectively.
+
+For further convenience, the CLIs support reading the schema from a specific
+"key" in that configuration file, which by default is set to `"kong"`. This
+allows you to keep your Kong schema alongside other configuration items for
+your application(s) in a single file.
+
+If your Kong schema is the root property, just pass `--key ""` to CLI commands
+to make them read the whole file as the schema.
+
 ### `admin_host: String`
 
+Address at which Kong Admin is listening, like `127.0.0.1:9712`. This is the
+value you specify in `admin_listen` of `kong.conf`.
+
 ### `apis: Array<Kong::Api>`
 
-[Kong::Api](https://getkong.org/docs/0.11.x/admin-api/#add-api) configuration:
+[Kong::Api](https://getkong.org/docs/0.11.x/admin-api/#add-api) configuration.
+
+**Properties**
 
 - name: String
 - host: String
@@ -174,10 +193,26 @@ Nice and easy!
 - upstream_url: String
 - uris: Array<String>
 
+### `plugins: Array<Kong::Plugin>`
+
+[Kong::Plugin](https://getkong.org/docs/0.11.x/admin-api/#add-plugin) configuration.
+
+Setting `enabled: false` will delete the plugin.
+
+**Properties**
+
+- name: String
+- enabled: Boolean
+- api_id: String
+- config: Object
+- consumer_id: String
+
 ### `upstreams: Array<Kong::Upstream>`
 
 [Kong::Upstream](https://getkong.org/docs/0.11.x/admin-api/#add-upstream)
-configuration:
+configuration.
+
+**Properties**
 
 - name: String
 - slots: Number
@@ -186,7 +221,9 @@ configuration:
 ### `targets: Array<Kong::Target>`
 
 [Kong::Target](https://getkong.org/docs/0.11.x/admin-api/#add-target)
-configuration:
+configuration.
+
+**Properties**
 
 - upstream_id: String
 - target: String
@@ -197,10 +234,51 @@ configuration:
 Add support for the remaining Kong API objects:
 
 - [consumers](https://getkong.org/docs/0.11.x/admin-api/#create-consumer)
-- [plugins](https://getkong.org/docs/0.11.x/admin-api/#add-plugin)
 - [certificates](https://getkong.org/docs/0.11.x/admin-api/#add-certificate)
 - [snis](https://getkong.org/docs/0.11.x/admin-api/#add-sni)
 
+## Gotchas
+
+Beware of removing keys that were previously defined in your configuration.
+`kong_schema` does not know the default values of options nor does it attempt
+to assign them, so when you omit an option that was previously defined, it can
+not detect that change and it will not be reflected in the API.
+
+This symptom may be addressed in the future by changing the implementation so
+that it wipes out Kong's configuration before each application (e.g.
+`kong_schema up`) but for now you have two options to deal with this:
+
+1) Reset the database prior to applying the schema:
+
+```shell
+kong_schema down [file] # database reset
+kong_schema up [file]   # database now 100% reflecting config file
+```
+
+2) Set the values to `null` or an empty property. For example, if we were to no
+   longer use the `hosts` property of an Api object, we'd just clear it instead
+   of omitting it:
+
+```yaml
+kong:
+  apis:
+    - name: some-api
+      # just clear this, don't omit it
+      hosts:
+```
+
+## Tests
+
+**WARNING: RUNNING THE TESTS WILL CLEAR THE KONG DATABASE!!!**
+
+A running Kong instance is required to run the tests. By default the admin API
+is expected to be running on `127.0.0.1:9712` but you can change that by 
+setting the environment variable `KONG_URI`.
+
+Then running the tests is as simple as:
+
+    COVERAGE=1 bundle exec rspec
+
 ## License
 
 Copyright (C) 2017 Instructure, INC.

data/lib/kong_schema/cli.rb

@@ -16,9 +16,19 @@ module KongSchema
 
       sort_help :manually
 
+      flag([ 'c', 'config' ], {
+        desc: 'Path to the configuration file (in place of the first argument.)',
+        arg_name: 'FILE'
+      })
+
       desc 'Apply configuration from a .yml or .json file.'
       arg(:config_file)
       command :up do |c|
+        c.flag([ 'c', 'config' ], {
+          desc: 'Path to the configuration file (in place of the first argument.)',
+          arg_name: 'FILE'
+        })
+
         c.flag([ 'k', 'key' ], {
           default_value: 'kong',
           desc: 'The root configuration property key.',
@@ -38,16 +48,16 @@ module KongSchema
           desc: 'Prompt for confirmation before applying changes.'
         })
 
-        c.action do |global_options, options, args|
-          bail! "Missing path to .yml or .json config file" if args.first.nil?
+        c.action do |globals, options, args|
+          filepath = resolve_config_file!(args: args, globals: globals, options: options)
 
-          up(filepath: args.first, options: options)
+          up(filepath: filepath, options: options)
         end
       end
 
       desc 'Reset Kong configuration completely.'
       arg(:config_file)
-      command :reset do |c|
+      command :down do |c|
         c.flag([ 'k', 'key' ], {
           default_value: 'kong',
           desc: 'The root configuration property key.',
@@ -59,10 +69,10 @@ module KongSchema
           desc: 'Prompt for confirmation before applying changes.'
         })
 
-        c.action do |global_options, options, args|
-          bail! "Missing path to .yml or .json config file" if args.first.nil?
+        c.action do |globals, options, args|
+          filepath = resolve_config_file!(args: args, globals: globals, options: options)
 
-          reset(filepath: args.first, options: options)
+          down(filepath: filepath, options: options)
         end
       end
 
@@ -91,7 +101,7 @@ module KongSchema
       end
     end
 
-    def reset(filepath:, options:)
+    def down(filepath:, options:)
       pastel = Pastel.new
       schema = KongSchema::Schema
       config = read_property(load_file(filepath), options[:key])
@@ -103,6 +113,16 @@ module KongSchema
       end
     end
 
+    def resolve_config_file!(args:, globals:, options:)
+      filepath = args.first || options[:config] || globals[:config]
+
+      if filepath.nil?
+        bail! "Missing path to .yml or .json config file"
+      else
+        filepath
+      end
+    end
+
     def load_file(filepath)
       if filepath.end_with?('.json')
         JSON.parse(File.read(filepath))
@@ -120,7 +140,7 @@ module KongSchema
     end
 
     def yes?(message, default: false)
-      TTY::Prompt.new.yes?(message, default: default)
+      TTY::Prompt.new.yes?(message, default: default, color: false)
     end
 
     def red(text)

data/lib/kong_schema/client.rb

@@ -30,6 +30,8 @@ module KongSchema
     # Reset Kong's database by removing all objects through the API.
     def self.purge(config)
       connect(config) do
+        KongSchema::Resource::Plugin.all.each(&:delete)
+
         KongSchema::Resource::Upstream.all.each do |upstream|
           upstream.targets.each(&:delete)
           upstream.delete

data/lib/kong_schema/functional.rb

@@ -3,5 +3,13 @@ module KongSchema
     def blank?(object)
       object.nil? || object.empty?
     end
+
+    def try(recv, meth)
+      if recv.nil?
+        nil
+      else
+        recv.send(meth)
+      end
+    end
   end
 end

data/lib/kong_schema/resource.rb

@@ -1,3 +1,4 @@
 require_relative './resource/api'
+require_relative './resource/plugin'
 require_relative './resource/target'
 require_relative './resource/upstream'

data/lib/kong_schema/resource/api.rb

@@ -27,6 +27,10 @@ module KongSchema
         Adapter.for(Kong::Api).create(serialize_outbound(attributes))
       end
 
+      def creatable?(*)
+        true
+      end
+
       def changed?(record, attributes)
         current = record.attributes.keys.reduce({}) do |map, key|
           value = record.attributes[key]

data/lib/kong_schema/resource/plugin.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'kong'
+require_relative '../adapter'
+require_relative '../functional'
+
+module KongSchema
+  module Resource
+    module Plugin
+      extend self
+      extend Functional
+
+      def identify(record)
+        case record
+        when Kong::Plugin
+          [ record.name, try(record.api, :name), record.consumer_id ]
+        when Hash
+          [ record['name'], record['api_id'], record['consumer_id'] ]
+        end
+      end
+
+      def all(*)
+        Kong::Plugin.all
+      end
+
+      def create(attributes)
+        Adapter.for(Kong::Plugin).create(attributes)
+      end
+
+      def creatable?(attributes)
+        attributes['enabled'] != false
+      end
+
+      def changed?(record, attributes)
+        current = record.attributes.keys.each_with_object({}) do |key, map|
+          value = record.attributes[key]
+
+          map[key] = case key
+          when 'api_id'
+            record.api.name
+          else
+            value
+          end
+        end
+
+        Adapter.for(Kong::Plugin).changed?(current, attributes)
+      end
+
+      def update(record, partial_attributes)
+        if partial_attributes['enabled'] == false
+          delete(record)
+        else
+          Adapter.for(Kong::Plugin).update(
+            record,
+            partial_attributes.merge('api_id' => record.api.id)
+          )
+        end
+      end
+
+      def delete(record)
+        Adapter.for(Kong::Plugin).delete(record)
+      end
+    end
+  end
+end

data/lib/kong_schema/resource/target.rb

@@ -29,6 +29,10 @@ module KongSchema
         end
       end
 
+      def creatable?(*)
+        true
+      end
+
       def changed?(record, directive)
         (
           record.target != directive['target'] ||

data/lib/kong_schema/resource/upstream.rb

@@ -26,6 +26,10 @@ module KongSchema
         Adapter.for(Kong::Upstream).create(attributes)
       end
 
+      def creatable?(*)
+        true
+      end
+
       def changed?(record, attributes)
         Adapter.for(Kong::Upstream).changed?(record.attributes, attributes)
       end

data/lib/kong_schema/schema.rb

@@ -23,6 +23,8 @@ module KongSchema
         [
           scan_in(model: Resource::Api, directives: Array(config['apis'])),
 
+          scan_in(model: Resource::Plugin, directives: Array(config['plugins'])),
+
           # order matters in some of the resources; Upstream directives must be
           # handled before Target ones
           scan_in(model: Resource::Upstream, directives: Array(config['upstreams'])),
@@ -73,7 +75,11 @@ module KongSchema
 
     def build_create_changes(model:, defined:, declared:)
       to_create = declared.keys - defined.keys
-      to_create.map do |id|
+      creatable = to_create.select do |id|
+        model.creatable?(declared[id])
+      end
+
+      creatable.map do |id|
         Actions::Create.new(model: model, params: declared[id])
       end
     end

data/lib/kong_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KongSchema
-  VERSION = "1.2.0".freeze
+  VERSION = "1.3.0".freeze
 end

data/spec/kong_schema/cli_spec.rb

@@ -0,0 +1,135 @@
+describe KongSchema::CLI do
+  let(:test_utils) { KongSchemaTestUtils.new }
+  let(:schema) { KongSchema::Schema }
+  let(:client) { KongSchema::Client }
+
+  let(:config) do
+    test_utils.generate_config({
+      apis: [{
+        name: 'my-api',
+        hosts: [ 'example.com' ],
+        upstream_url: 'http://example'
+      }]
+    })
+  end
+
+  let(:keyed_config) do
+    {
+      "kong" => config
+    }
+  end
+
+  describe 'up' do
+    it 'complains if no file was passed' do
+      expect(subject).to receive(:bail!)
+        .with('Missing path to .yml or .json config file')
+        .and_call_original
+
+      expect {
+        subject.run(["up"])
+      }.to  output(/Missing path to/).to_stderr_from_any_process
+       .and output(/SYNOPSIS/).to_stdout_from_any_process # help listing
+    end
+
+    it 'works' do
+      test_utils.generate_config_file(config) do |filepath|
+        expect {
+          subject.run(["up", filepath, "--no-confirm", "--key", ""])
+        }.to  change { client.connect(config) { Kong::Api.all.count } }.by(1)
+         .and output(/Kong has been reconfigured!/).to_stdout
+      end
+    end
+
+    it 'works (with a JSON file)' do
+      test_utils.generate_config_file(config, format: :json) do |filepath|
+        expect {
+          subject.run(["up", filepath, "--no-confirm", "--key", ""])
+        }.to  change { client.connect(config) { Kong::Api.all.count } }.by(1)
+         .and output(/Kong has been reconfigured!/).to_stdout
+      end
+    end
+
+    it 'accepts config file using -c for consistency with Kong' do
+      test_utils.generate_config_file(keyed_config) do |filepath|
+        expect {
+          subject.run(["up", "-c", filepath, "--no-confirm"])
+        }.to  change { client.connect(config) { Kong::Api.all.count } }.by(1)
+         .and output(/Kong has been reconfigured!/).to_stdout
+      end
+    end
+
+    it 'accepts config file using -c (globally) for convenience' do
+      test_utils.generate_config_file(keyed_config) do |filepath|
+        expect {
+          subject.run(["-c", filepath, "up", "--no-confirm"])
+        }.to  change { client.connect(config) { Kong::Api.all.count } }.by(1)
+         .and output(/Kong has been reconfigured!/).to_stdout
+      end
+    end
+
+    it 'reads config from a custom key' do
+      test_utils.generate_config_file(keyed_config) do |filepath|
+        expect {
+          subject.run(["up", filepath, "--no-confirm", "--key", "kong"])
+        }.to  change { client.connect(config) { Kong::Api.all.count } }.by(1)
+         .and output(/Kong has been reconfigured!/).to_stdout
+      end
+    end
+
+    it 'prompts for confirmation' do
+      test_utils.fake_stdin(["y"]) do
+        test_utils.generate_config_file(keyed_config) do |filepath|
+          expect {
+            subject.run(["up", filepath])
+          }.to  change { client.connect(config) { Kong::Api.all.count } }.by(1)
+           .and output(/Kong has been reconfigured!/).to_stdout
+        end
+      end
+    end
+
+    it 'aborts if not confirmed' do
+      test_utils.fake_stdin(["n"]) do
+        test_utils.generate_config_file(keyed_config) do |filepath|
+          expect {
+            subject.run(["up", filepath])
+          }.to  change { client.connect(config) { Kong::Api.all.count } }.by(0)
+           .and output.to_stdout
+        end
+      end
+    end
+
+    it 'does nothing if there are no changes to commit' do
+      config = test_utils.generate_config({})
+
+      test_utils.generate_config_file(config) do |filepath|
+        expect {
+          subject.run(["up", filepath, "--no-confirm", "--key", ""])
+        }.to output(/Nothing to update./).to_stdout
+      end
+    end
+  end
+
+  describe 'down' do
+    it 'complains if no file was passed' do
+      expect(subject).to receive(:bail!)
+        .with('Missing path to .yml or .json config file')
+        .and_call_original
+
+      expect {
+        subject.run(["down"])
+      }.to  output(/Missing path to/).to_stderr_from_any_process
+       .and output(/SYNOPSIS/).to_stdout_from_any_process # help listing
+    end
+
+    it 'works' do
+      KongSchema::Schema.commit(config, KongSchema::Schema.scan(config))
+
+      test_utils.generate_config_file(config) do |filepath|
+        expect {
+          subject.run(["down", filepath, "--no-confirm", "--key", ""])
+        }.to  change { client.connect(config) { Kong::Api.all.count } }.by(-1)
+         .and output(/Kong reset\./).to_stdout
+      end
+    end
+  end
+end

data/spec/kong_schema/client_spec.rb

@@ -0,0 +1,9 @@
+describe KongSchema::Client do
+  describe 'connect' do
+    it 'whines if "admin_host" is undefined' do
+      expect {
+        described_class.connect({})
+      }.to raise_error("Missing 'admin_host' property; can not connect to Kong admin!")
+    end
+  end
+end

data/spec/kong_schema/reporter_spec.rb

@@ -4,10 +4,6 @@ describe KongSchema::Reporter do
   let(:test_utils) { KongSchemaTestUtils.new }
   let(:schema) { KongSchema::Schema }
 
-  after(:each) do
-    test_utils.reset_kong
-  end
-
   let :config do
     test_utils.generate_config({
       upstreams: [{ name: 'bridge-learn.kong-service' }]

data/spec/kong_schema/resource/api_spec.rb

@@ -2,10 +2,6 @@ describe KongSchema::Resource::Api do
   let(:schema) { KongSchema::Schema }
   let(:test_utils) { KongSchemaTestUtils.new }
 
-  after(:each) do
-    test_utils.reset_kong
-  end
-
   describe 'creating APIs' do
     let :config do
       test_utils.generate_config({

data/spec/kong_schema/resource/plugin_spec.rb

@@ -0,0 +1,117 @@
+describe KongSchema::Resource::Plugin do
+  let(:schema) { KongSchema::Schema }
+  let(:test_utils) { KongSchemaTestUtils.new }
+
+  let :plugin_config do
+    {
+      second: 120
+    }
+  end
+
+  let :config do
+    test_utils.generate_config({
+      apis: [{
+        name: 'my-api',
+        upstream_url: 'http://example.com',
+        hosts: [ 'example.com' ]
+      }],
+
+      plugins: [{
+        name: 'rate-limiting',
+        api_id: 'my-api',
+        enabled: true,
+        config: plugin_config
+      }]
+    })
+  end
+
+  it 'adds a plugin if it does not exist' do
+    directives = schema.scan(config)
+
+    expect(directives.map(&:class)).to eq([
+      KongSchema::Actions::Create,
+      KongSchema::Actions::Create
+    ])
+  end
+
+  it 'does add a plugin' do
+    directives = schema.scan(config)
+
+    expect {
+      schema.commit(config, directives)
+    }.to change {
+      KongSchema::Client.connect(config) {
+        Kong::Plugin.all.count
+      }
+    }.by(1)
+  end
+
+  it 'updates a plugin' do
+    schema.commit(config, schema.scan(config))
+
+    with_update = test_utils.generate_config({
+      apis: [{
+        name: 'my-api',
+        upstream_url: 'http://example.com',
+        hosts: [ 'example.com' ]
+      }],
+
+      plugins: [{
+        config: plugin_config.merge({ second: 60 }),
+        name: 'rate-limiting',
+        api_id: 'my-api',
+      }]
+    })
+
+    expect { schema.commit(config, schema.scan(with_update)) }.to change {
+      KongSchema::Client.connect(config) {
+        Kong::Plugin.find_by_name('rate-limiting').config['second']
+      }
+    }.from(120).to(60)
+  end
+
+  it 'removes the plugin if enabled is set to false' do
+    schema.commit(config, schema.scan(config))
+
+    with_update = test_utils.generate_config({
+      apis: [{
+        name: 'my-api',
+        upstream_url: 'http://example.com',
+        hosts: [ 'example.com' ]
+      }],
+
+      plugins: [{
+        name: 'rate-limiting',
+        api_id: 'my-api',
+        config: plugin_config,
+        enabled: false
+      }]
+    })
+
+    expect { schema.commit(config, schema.scan(with_update)) }.to change {
+      KongSchema::Client.connect(config) {
+        Kong::Plugin.all.count
+      }
+    }.by(-1)
+  end
+
+  it 'removes the plugin if it is no longer specified' do
+    schema.commit(config, schema.scan(config))
+
+    with_removal = test_utils.generate_config({
+      apis: [{
+        name: 'my-api',
+        upstream_url: 'http://example.com',
+        hosts: [ 'example.com' ]
+      }],
+
+      plugins: []
+    })
+
+    expect { schema.commit(config, schema.scan(with_removal)) }.to change {
+      KongSchema::Client.connect(config) {
+        Kong::Plugin.all.count
+      }
+    }.by(-1)
+  end
+end

data/spec/kong_schema/resource/target_spec.rb

@@ -2,10 +2,6 @@ describe KongSchema::Resource::Target do
   let(:schema) { KongSchema::Schema }
   let(:test_utils) { KongSchemaTestUtils.new }
 
-  after(:each) do
-    test_utils.reset_kong
-  end
-
   describe 'creating targets' do
     let :config do
       test_utils.generate_config({

data/spec/kong_schema/resource/upstream_spec.rb

@@ -2,10 +2,6 @@ describe KongSchema::Resource::Upstream do
   let(:schema) { KongSchema::Schema }
   let(:test_utils) { KongSchemaTestUtils.new }
 
-  after(:each) do
-    test_utils.reset_kong
-  end
-
   describe 'creating upstreams' do
     let :config do
       test_utils.generate_config({

data/spec/spec_helper.rb

@@ -19,8 +19,14 @@ require 'kong_schema'
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.before(:all) do
-    KongSchemaTestUtils.new.reset_kong
+  test_utils = KongSchemaTestUtils.new
+
+  config.before(:each) do
+    test_utils.reset_kong
+  end
+
+  config.after(:each) do
+    test_utils.reset_kong
   end
 
   # rspec-expectations config goes here. You can use an alternate

data/spec/support/kong_schema_test_utils.rb

@@ -1,4 +1,5 @@
 require 'kong_schema'
+require 'fileutils'
 
 class KongSchemaTestUtils
   attr_reader :host
@@ -11,6 +12,38 @@ class KongSchemaTestUtils
     JSON.parse(JSON.dump({ admin_host: host }.merge(config)))
   end
 
+  def generate_config_file(config = {}, format: :yaml)
+    buffer = case format
+    when :json
+      JSON.dump(config)
+    else
+      YAML.dump(config)
+    end
+
+    filename = case format
+    when :json
+      'config.json'
+    else
+      'config.yaml'
+    end
+
+    filepath = File.join(Dir.pwd, 'spec', 'fixtures', filename)
+
+    File.write(filepath, buffer)
+    yield filepath
+  ensure
+    FileUtils.rm(filepath)
+  end
+
+  def fake_stdin(*args)
+    $stdin = StringIO.new
+    $stdin.puts(args.shift) until args.empty?
+    $stdin.rewind
+    yield
+  ensure
+    $stdin = STDIN
+  end
+
   def reset_kong
     KongSchema::Client.purge(generate_config)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kong_schema
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Ahmad Amireh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-12 00:00:00.000000000 Z
+date: 2017-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gli
@@ -165,13 +165,18 @@ files:
 - lib/kong_schema/reporter.rb
 - lib/kong_schema/resource.rb
 - lib/kong_schema/resource/api.rb
+- lib/kong_schema/resource/plugin.rb
 - lib/kong_schema/resource/target.rb
 - lib/kong_schema/resource/upstream.rb
 - lib/kong_schema/schema.rb
 - lib/kong_schema/version.rb
 - spec/examples.txt
+- spec/fixtures/.gitkeep
+- spec/kong_schema/cli_spec.rb
+- spec/kong_schema/client_spec.rb
 - spec/kong_schema/reporter_spec.rb
 - spec/kong_schema/resource/api_spec.rb
+- spec/kong_schema/resource/plugin_spec.rb
 - spec/kong_schema/resource/target_spec.rb
 - spec/kong_schema/resource/upstream_spec.rb
 - spec/spec_helper.rb
@@ -203,8 +208,12 @@ specification_version: 4
 summary: Configure Kong from a file using its REST API.
 test_files:
 - spec/examples.txt
+- spec/fixtures/.gitkeep
+- spec/kong_schema/cli_spec.rb
+- spec/kong_schema/client_spec.rb
 - spec/kong_schema/reporter_spec.rb
 - spec/kong_schema/resource/api_spec.rb
+- spec/kong_schema/resource/plugin_spec.rb
 - spec/kong_schema/resource/target_spec.rb
 - spec/kong_schema/resource/upstream_spec.rb
 - spec/spec_helper.rb