kubecontrol 0.2.5 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 707a8841200476fc3adf97d63d744169629cf6a03993a43e8c771d73a6a4c80a
-  data.tar.gz: 715c7157780f9e909e0a3cc2dfdc15a3c948dbc79529de91c4fc2504309a4d89
+  metadata.gz: 16ffbd150b8509fd48aafeb8caf01321335687af651155c69737e0e931b0fa58
+  data.tar.gz: 2c64c013191b415b3296e43fbd20a95b2ad82c76207d7a5f4ce2878914fa10ca
 SHA512:
-  metadata.gz: 5a748ff7cf8eafcca984455fa9590db79edad8b44014c425b9a607e8521b48d7dbd24ff3db070e13862968d8c636b826ae25081fdfe4ad039a4c305cda1bbdad
-  data.tar.gz: 2197d756a9568cc3ff3d7a7f1e589a08d93905d08b2ea97d485c026d5b54d25931c1d86ccaf90305e140fbabbee7e13e1b3eb3ab321f1210d352d585d574471a
+  metadata.gz: e4f4c1831fa2186e2b17c68c6bc2333dab39b0709c7cd887b775d62de93d1471a00cef49afb80937b62a8736b6fe5508db66dc9605a4da85d6538fc4b4b71d2c
+  data.tar.gz: 1ebf4b5a383a8300ba99e72871abe9dd878852610ab09a9e3badaf2c30ef113e54730a313bb2af00dd5f568894ed6bbb2f88f667b3f9627fb42198357c33dc73

data/.github/workflows/{ruby.yml → unit_tests.yml}

@@ -1,4 +1,4 @@
-name: Ruby
+name: Unit Tests
 
 on: [push]
 

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.3.5 / 02-21-2020
+- [FEATURE] Kubecontrol::Deployment
+- [FEATURE] Kubecontrol::StatefulSet
+
 # v0.2.5 / 02-18-2020
 - [FEATURE] Kubecontrol::Service
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kubecontrol (0.2.5)
+    kubecontrol (0.3.5)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -20,6 +20,7 @@ Or install it yourself as:
 
 ## Usage
 
+##### kubectl Commands
 ```ruby
 require 'kubecontrol'
 
@@ -28,6 +29,15 @@ kubectl_client =  Kubecontrol.client.new
 
 #Exec an arbitrary kubectl command
 std_out, std_err, exit_code = kubectl_client.kubectl_command 'get deployments'
+```
+
+#### Pods
+
+```ruby
+require 'kubecontrol'
+
+# create new client
+kubectl_client =  Kubecontrol.client.new
 
 # all pods for namespace
 pods = kubectl_client.pods
@@ -47,6 +57,94 @@ pod.namespace
 std_out, std_err, exit_code = pod.exec('ls')
 ```
 
+#### Services
+
+```ruby
+require 'kubecontrol'
+
+# create new client
+kubectl_client =  Kubecontrol.client.new
+
+# all services for namespace
+services = kubectl_client.services
+
+# find service by name regex
+service = kubectl_client.find_service_by_name /foo-api-.*/
+
+# access service information
+service.name
+service.type
+service.cluster_ip
+service.external_ip
+service.ports
+service.age
+service.namespace
+```
+
+#### Deployments
+
+```ruby
+require 'kubecontrol'
+
+# create new client
+kubectl_client =  Kubecontrol.client.new
+
+# all deployments for namespace
+deployments = kubectl_client.deployments
+
+# find deployment by name regex
+deployment = kubectl_client.find_deployment_by_name /foo-api-.*/
+
+# access deployment information
+deployment.name
+deployment.ready
+deployment.up_to_date
+deployment.available
+deployment.age
+deployment.namespace
+
+# is deployment ready
+deployment.ready?
+deployment.all_ready?
+
+# is deployment available
+deployment.available?
+
+# is deployment up_to_date
+deployment.up_to_date?
+
+# scale deployment
+deployment.scale(5)
+```
+
+#### StatefulSets
+
+```ruby
+require 'kubecontrol'
+
+# create new client
+kubectl_client =  Kubecontrol.client.new
+
+# all stateful_sets for namespace
+stateful_sets = kubectl_client.stateful_sets
+
+# find stateful_set by name regex
+stateful_set = kubectl_client.find_stateful_set_by_name /foo-api-.*/
+
+# access stateful_set information
+stateful_set.name
+stateful_set.ready
+stateful_set.age
+stateful_set.namespace
+
+# is stateful_set ready
+stateful_set.ready?
+stateful_set.all_ready?
+
+# scale stateful_set
+stateful_set.scale(5)
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -56,3 +154,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/madkin10/kubecontrol.
+
+## Contributors
+ - [Dustin Ashley](https://github.com/DustinAshley)

data/lib/kubecontrol.rb

@@ -1,6 +1,9 @@
 require 'kubecontrol/version'
 require 'kubecontrol/client'
 require 'kubecontrol/pod'
+require 'kubecontrol/service'
+require 'kubecontrol/stateful_set'
+require 'kubecontrol/deployment'
 
 module Kubecontrol
   class Error < StandardError; end

data/lib/kubecontrol/client.rb

@@ -1,5 +1,7 @@
 require 'open3'
 require_relative 'pod'
+require_relative 'deployment'
+require_relative 'stateful_set'
 require_relative 'service'
 
 module Kubecontrol
@@ -16,14 +18,34 @@ module Kubecontrol
       get_resource(Pod, 5)
     end
 
-    def find_pod_by_name(name_regex)
-      pods.find { |pod| pod.name.match?(name_regex) }
+    def deployments
+      get_resource(Deployment, 5)
+    end
+
+    def stateful_sets
+      get_resource(StatefulSet, 3)
     end
 
     def services
       get_resource(Service, 6)
     end
 
+    def find_service_by_name(name_regex)
+      services.find { |service| service.name.match?(name_regex) }
+    end
+
+    def find_pod_by_name(name_regex)
+      pods.find { |pod| pod.name.match?(name_regex) }
+    end
+
+    def find_deployment_by_name(name_regex)
+      deployments.find { |deployment| deployment.name.match?(name_regex) }
+    end
+
+    def find_stateful_set_by_name(name_regex)
+      stateful_sets.find { |stateful_set| stateful_set.name.match?(name_regex) }
+    end
+
     def kubectl_command(command)
       stdout_data, stderr_data, status = Open3.capture3("kubectl -n #{namespace} #{command}")
       exit_code = status.exitstatus

data/lib/kubecontrol/deployment.rb

@@ -0,0 +1,38 @@
+module Kubecontrol
+  class Deployment
+    RESOURCE_NAME = 'deployments'.freeze
+
+    attr_reader :name, :ready, :up_to_date, :available, :age, :namespace, :client
+
+    def initialize(name, ready, up_to_date, available, age, namespace, client)
+      @name = name
+      @ready = ready
+      @up_to_date = up_to_date
+      @available = available
+      @age = age
+      @namespace = namespace
+      @client = client
+    end
+
+    def ready?
+      @ready.split('/').first != '0'
+    end
+
+    def all_ready?
+      max_pods = @ready.split('/').last
+      @ready == "#{max_pods}/#{max_pods}"
+    end
+
+    def available?
+      @available.to_i > 1
+    end
+
+    def up_to_date?
+      @up_to_date.to_i > 1
+    end
+
+    def scale(count)
+      @client.kubectl_command("scale deployment #{@name} --replicas=#{count}")
+    end
+  end
+end

data/lib/kubecontrol/pod.rb

@@ -23,6 +23,11 @@ module Kubecontrol
       @status == RUNNING
     end
 
+    def ready?
+      pod_containers = @ready.split('/').last
+      @ready == "#{pod_containers}/#{pod_containers}"
+    end
+
     def exec(command)
       @client.kubectl_command("exec -i #{name} -- sh -c \"#{command.gsub('"', '\"')}\"")
     end

data/lib/kubecontrol/stateful_set.rb

@@ -0,0 +1,28 @@
+module Kubecontrol
+  class StatefulSet
+    RESOURCE_NAME = 'statefulsets'.freeze
+
+    attr_reader :name, :ready, :age, :namespace, :client
+
+    def initialize(name, ready, age, namespace, client)
+      @name = name
+      @ready = ready
+      @age = age
+      @namespace = namespace
+      @client = client
+    end
+
+    def ready?
+      @ready.split('/').first != '0'
+    end
+
+    def all_ready?
+      max_pods = @ready.split('/').last
+      @ready == "#{max_pods}/#{max_pods}"
+    end
+
+    def scale(count)
+      @client.kubectl_command("scale statefulset #{@name} --replicas=#{count}")
+    end
+  end
+end

data/lib/kubecontrol/version.rb

@@ -1,3 +1,3 @@
 module Kubecontrol
-  VERSION = '0.2.5'.freeze
+  VERSION = '0.3.5'.freeze
 end

data/spec/kubecontrol/client_spec.rb

@@ -2,25 +2,58 @@ require_relative '../spec_helper'
 
 RSpec.describe Kubecontrol::Client do
   let(:custom_namespace) { 'custom_namespace' }
-  let(:pod_name) { 'foo_pod' }
-  let(:pod_ready) { '1/1' }
+  let(:name) { 'foo_pod' }
+  let(:ready) { '1/1' }
+  let(:age) { '20d' }
+  let(:process_status) do
+    fork { exit }
+    $CHILD_STATUS
+  end
+
   let(:pod_status) { 'Running' }
   let(:pod_restarts) { '0' }
-  let(:pod_age) { '20d' }
-
   let(:get_pods_std_out) do
     <<~RUBY
-      NAME         READY         STATUS         RESTARTS         AGE
-      #{pod_name}  #{pod_ready}  #{pod_status}  #{pod_restarts}  #{pod_age}
+      NAME     READY     STATUS         RESTARTS         AGE
+      #{name}  #{ready}  #{pod_status}  #{pod_restarts}  #{age}
     RUBY
   end
   let(:get_pods_std_err) { '' }
-  let(:process_status) do
-    fork { exit }
-    $CHILD_STATUS
-  end
   let(:get_pods_response) { [get_pods_std_out, get_pods_std_err, process_status] }
 
+  let(:service_type) { 'ClusterIP' }
+  let(:service_cluster_ip) { '172.20.0.1' }
+  let(:service_external_ip) { '<none>' }
+  let(:service_ports) { '443/TCP' }
+  let(:get_services_std_out) do
+    <<~RUBY
+      NAME     TYPE             CLUSTER_IP             EXTERNAL-IP             PORT(S)           AGE
+      #{name}  #{service_type}  #{service_cluster_ip}  #{service_external_ip}  #{service_ports}  #{age}
+    RUBY
+  end
+  let(:get_services_std_err) { '' }
+  let(:get_services_response) { [get_services_std_out, get_services_std_err, process_status] }
+
+  let(:deployments_up_to_date) { '1' }
+  let(:deployments_available) { '1' }
+  let(:get_deployments_std_out) do
+    <<~RUBY
+      NAME     READY     UP-TO-DATE                 AVAILABLE                 AGE
+      #{name}  #{ready}  #{deployments_up_to_date}  #{deployments_available}  #{age}
+    RUBY
+  end
+  let(:get_deployments_std_err) { '' }
+  let(:get_deployments_response) { [get_deployments_std_out, get_deployments_std_err, process_status] }
+
+  let(:get_stateful_sets_std_out) do
+    <<~RUBY
+      NAME     READY     AGE
+      #{name}  #{ready}  #{age}
+    RUBY
+  end
+  let(:get_stateful_sets_std_err) { '' }
+  let(:get_stateful_sets_response) { [get_stateful_sets_std_out, get_stateful_sets_std_err, process_status] }
+
   describe '#initialize' do
     subject { Kubecontrol::Client }
 
@@ -78,7 +111,7 @@ RSpec.describe Kubecontrol::Client do
   end
 
   describe '#find_pod_by_name' do
-    subject { Kubecontrol::Client.new.find_pod_by_name(pod_name) }
+    subject { Kubecontrol::Client.new.find_pod_by_name(name) }
 
     before do
       allow(Open3).to receive(:capture3).and_return get_pods_response
@@ -87,7 +120,7 @@ RSpec.describe Kubecontrol::Client do
     it { is_expected.to be_an_instance_of Kubecontrol::Pod }
 
     it 'returns the correct pod' do
-      expect(subject.name).to eq pod_name
+      expect(subject.name).to eq name
     end
 
     context 'pod does not exist' do
@@ -96,4 +129,145 @@ RSpec.describe Kubecontrol::Client do
       it { is_expected.to be_nil }
     end
   end
+
+  describe '#services' do
+    subject { Kubecontrol::Client.new.services }
+
+    it 'send a kubectl request to the command line' do
+      expect(Open3).to receive(:capture3).with('kubectl -n default get services').and_return get_services_response
+      subject
+    end
+
+    it 'returns an array of Kubecontrol::Services' do
+      allow(Open3).to receive(:capture3).and_return get_services_response
+      result = subject
+      expect(result).to be_an_instance_of Array
+      expect(result.length).to eq 1
+      expect(result.first).to be_an_instance_of Kubecontrol::Service
+    end
+
+    context 'no services found' do
+      let(:get_services_std_out) { '' }
+
+      before do
+        allow(Open3).to receive(:capture3).and_return get_services_response
+      end
+
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe '#find_service_by_name' do
+    subject { Kubecontrol::Client.new.find_service_by_name(name) }
+
+    before do
+      allow(Open3).to receive(:capture3).and_return get_services_response
+    end
+
+    it { is_expected.to be_an_instance_of Kubecontrol::Service }
+
+    it 'returns the correct service' do
+      expect(subject.name).to eq name
+    end
+
+    context 'service does not exist' do
+      let(:get_services_std_out) { '' }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#deployments' do
+    subject { Kubecontrol::Client.new.deployments }
+
+    it 'send a kubectl request to the command line' do
+      expect(Open3).to receive(:capture3).with('kubectl -n default get deployments').and_return get_deployments_response
+      subject
+    end
+
+    it 'returns an array of Kubecontrol::Deployments' do
+      allow(Open3).to receive(:capture3).and_return get_deployments_response
+      result = subject
+      expect(result).to be_an_instance_of Array
+      expect(result.length).to eq 1
+      expect(result.first).to be_an_instance_of Kubecontrol::Deployment
+    end
+
+    context 'no deployments found' do
+      let(:get_deployments_std_out) { '' }
+
+      before do
+        allow(Open3).to receive(:capture3).and_return get_deployments_response
+      end
+
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe '#find_deployment_by_name' do
+    subject { Kubecontrol::Client.new.find_deployment_by_name(name) }
+
+    before do
+      allow(Open3).to receive(:capture3).and_return get_deployments_response
+    end
+
+    it { is_expected.to be_an_instance_of Kubecontrol::Deployment }
+
+    it 'returns the correct deployment' do
+      expect(subject.name).to eq name
+    end
+
+    context 'deployment does not exist' do
+      let(:get_deployments_std_out) { '' }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#stateful_sets' do
+    subject { Kubecontrol::Client.new.stateful_sets }
+
+    it 'send a kubectl request to the command line' do
+      expect(Open3).to receive(:capture3).with('kubectl -n default get statefulsets').and_return get_stateful_sets_response
+      subject
+    end
+
+    it 'returns an array of Kubecontrol::StatefulSet' do
+      allow(Open3).to receive(:capture3).and_return get_stateful_sets_response
+      result = subject
+      expect(result).to be_an_instance_of Array
+      expect(result.length).to eq 1
+      expect(result.first).to be_an_instance_of Kubecontrol::StatefulSet
+    end
+
+    context 'no stateful_sets found' do
+      let(:get_stateful_sets_std_out) { '' }
+
+      before do
+        allow(Open3).to receive(:capture3).and_return get_stateful_sets_response
+      end
+
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe '#find_stateful_set_by_name' do
+    subject { Kubecontrol::Client.new.find_stateful_set_by_name(name) }
+
+    before do
+      allow(Open3).to receive(:capture3).and_return get_stateful_sets_response
+    end
+
+    it { is_expected.to be_an_instance_of Kubecontrol::StatefulSet }
+
+    it 'returns the correct stateful_sets' do
+      expect(subject.name).to eq name
+    end
+
+    context 'stateful_set does not exist' do
+      let(:get_stateful_sets_std_out) { '' }
+
+      it { is_expected.to be_nil }
+    end
+  end
 end

data/spec/kubecontrol/deployment_spec.rb

@@ -0,0 +1,158 @@
+require_relative '../spec_helper'
+require_relative '../../lib/kubecontrol/deployment'
+
+RSpec.describe Kubecontrol::Deployment do
+  let(:deployment_name) { 'foo_deployment' }
+  let(:deployment_age) { '2d' }
+  let(:deployment_ready) { '1/1' }
+  let(:deployment_up_to_date) { '1' }
+  let(:deployment_available) { '1' }
+  let(:namespace) { 'default' }
+  let(:client) { Kubecontrol::Client.new }
+  let(:deployment) { Kubecontrol::Deployment.new(deployment_name, deployment_ready, deployment_up_to_date, deployment_available, deployment_age, namespace, client) }
+
+  describe '#initialize' do
+    subject { deployment }
+
+    it 'sets the deployment name field' do
+      expect(subject.name).to eq deployment_name
+    end
+
+    it 'sets the deployment age field' do
+      expect(subject.age).to eq deployment_age
+    end
+
+    it 'sets the deployment ready field' do
+      expect(subject.ready).to eq deployment_ready
+    end
+
+    it 'sets the deployment up to date field' do
+      expect(subject.up_to_date).to eq deployment_up_to_date
+    end
+
+    it 'sets the deployment available field' do
+      expect(subject.available).to eq deployment_available
+    end
+
+    it 'sets the deployment namespace' do
+      expect(subject.namespace).to eq namespace
+    end
+
+    it 'sets the client' do
+      expect(subject.client).to eq client
+    end
+  end
+
+  describe '#ready?' do
+    subject { deployment.ready? }
+
+    context 'all replicas running' do
+      let(:deployment_ready) { '3/3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'some replicas not running' do
+      let(:deployment_ready) { '2/3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'no replicas running' do
+      let(:deployment_ready) { '0/3' }
+
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe '#all_ready?' do
+    subject { deployment.all_ready? }
+
+    context 'all replicas running' do
+      let(:deployment_ready) { '3/3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'some replicas not running' do
+      let(:deployment_ready) { '2/3' }
+
+      it { is_expected.to eq false }
+    end
+
+    context 'no replicas running' do
+      let(:deployment_ready) { '0/3' }
+
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe '#available?' do
+    subject { deployment.available? }
+
+    context 'all replicas available' do
+      let(:deployment_available) { '3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'some replicas not available' do
+      let(:deployment_available) { '2' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'no replicas available' do
+      let(:deployment_available) { '0' }
+
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe '#up_to_date?' do
+    subject { deployment.up_to_date? }
+
+    context 'all replicas up to date' do
+      let(:deployment_up_to_date) { '3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'some replicas not up to date' do
+      let(:deployment_up_to_date) { '2' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'no replicas up to date' do
+      let(:deployment_up_to_date) { '0' }
+
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe '#scale' do
+    let(:scale_count) { '5' }
+
+    let(:kubectl_command) { "scale deployment #{deployment_name} --replicas=#{scale_count}" }
+    let(:std_out) { "deployment.extensions/#{deployment_name} scaled" }
+    let(:std_err) { '' }
+    let(:status_code) { 0 }
+    let(:kubectl_command_response) { [std_out, std_err, status_code] }
+
+    subject { deployment.scale(scale_count) }
+
+    it 'sends the scale command via Kubecontrol::Client#kubectl_command' do
+      expect(deployment.client).to receive(:kubectl_command).with(kubectl_command).and_return kubectl_command_response
+      subject
+    end
+
+    it 'returns an array of std_out, std_err, and status code' do
+      allow(deployment.client).to receive(:kubectl_command).with(kubectl_command).and_return kubectl_command_response
+      std_out_response, std_err_response, status_code_response = subject
+      expect(std_out_response).to eq std_out
+      expect(std_err_response).to eq std_err
+      expect(status_code_response).to eq status_code
+    end
+  end
+end

data/spec/kubecontrol/stateful_set_spec.rb

@@ -0,0 +1,104 @@
+require_relative '../spec_helper'
+require_relative '../../lib/kubecontrol/stateful_set'
+
+RSpec.describe Kubecontrol::StatefulSet do
+  let(:stateful_set_name) { 'foo_stateful_set' }
+  let(:stateful_set_age) { '2d' }
+  let(:stateful_set_ready) { '1/1' }
+  let(:namespace) { 'default' }
+  let(:client) { Kubecontrol::Client.new }
+  let(:stateful_set) { Kubecontrol::StatefulSet.new(stateful_set_name, stateful_set_ready, stateful_set_age, namespace, client) }
+
+  describe '#initialize' do
+    subject { stateful_set }
+
+    it 'sets the stateful_set name field' do
+      expect(subject.name).to eq stateful_set_name
+    end
+
+    it 'sets the stateful_set age field' do
+      expect(subject.age).to eq stateful_set_age
+    end
+
+    it 'sets the stateful_set ready field' do
+      expect(subject.ready).to eq stateful_set_ready
+    end
+
+    it 'sets the stateful_set namespace' do
+      expect(subject.namespace).to eq namespace
+    end
+
+    it 'sets the client' do
+      expect(subject.client).to eq client
+    end
+  end
+
+  describe '#ready?' do
+    subject { stateful_set.ready? }
+
+    context 'all replicas running' do
+      let(:stateful_set_ready) { '3/3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'some replicas not running' do
+      let(:stateful_set_ready) { '2/3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'no replicas running' do
+      let(:stateful_set_ready) { '0/3' }
+
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe '#all_ready?' do
+    subject { stateful_set.all_ready? }
+
+    context 'all replicas running' do
+      let(:stateful_set_ready) { '3/3' }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'some replicas not running' do
+      let(:stateful_set_ready) { '2/3' }
+
+      it { is_expected.to eq false }
+    end
+
+    context 'no replicas running' do
+      let(:stateful_set_ready) { '0/3' }
+
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe '#scale' do
+    let(:scale_count) { '5' }
+
+    let(:kubectl_command) { "scale statefulset #{stateful_set_name} --replicas=#{scale_count}" }
+    let(:std_out) { "stateful_set.extensions/#{stateful_set_name} scaled" }
+    let(:std_err) { '' }
+    let(:status_code) { 0 }
+    let(:kubectl_command_response) { [std_out, std_err, status_code] }
+
+    subject { stateful_set.scale(scale_count) }
+
+    it 'sends the scale command via Kubecontrol::Client#kubectl_command' do
+      expect(stateful_set.client).to receive(:kubectl_command).with(kubectl_command).and_return kubectl_command_response
+      subject
+    end
+
+    it 'returns an array of std_out, std_err, and status code' do
+      allow(stateful_set.client).to receive(:kubectl_command).with(kubectl_command).and_return kubectl_command_response
+      std_out_response, std_err_response, status_code_response = subject
+      expect(std_out_response).to eq std_out
+      expect(std_err_response).to eq std_err
+      expect(status_code_response).to eq status_code
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kubecontrol
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.5
 platform: ruby
 authors:
 - Marco Adkins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-18 00:00:00.000000000 Z
+date: 2020-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,8 +75,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/gempush.yml"
-- ".github/workflows/ruby.yml"
+- ".github/workflows/unit_tests.yml"
 - ".gitignore"
 - ".rspec"
 - CHANGELOG.md
@@ -90,12 +89,16 @@ files:
 - kubecontrol.gemspec
 - lib/kubecontrol.rb
 - lib/kubecontrol/client.rb
+- lib/kubecontrol/deployment.rb
 - lib/kubecontrol/pod.rb
 - lib/kubecontrol/service.rb
+- lib/kubecontrol/stateful_set.rb
 - lib/kubecontrol/version.rb
 - spec/kubecontrol/client_spec.rb
+- spec/kubecontrol/deployment_spec.rb
 - spec/kubecontrol/pod_spec.rb
 - spec/kubecontrol/service_spec.rb
+- spec/kubecontrol/stateful_set_spec.rb
 - spec/kubecontrol_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/madkin10/kubecontrol
@@ -120,8 +123,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Simple ruby wrapper for `kubectl` commands
-test_files: []
+test_files:
+- spec/kubecontrol/client_spec.rb
+- spec/kubecontrol/deployment_spec.rb
+- spec/kubecontrol/pod_spec.rb
+- spec/kubecontrol/service_spec.rb
+- spec/kubecontrol/stateful_set_spec.rb
+- spec/kubecontrol_spec.rb
+- spec/spec_helper.rb

data/.github/workflows/gempush.yml

@@ -1,44 +0,0 @@
-name: Ruby Gem
-
-on:
-  pull_request:
-    branches:
-      - master
-  push:
-    branches:
-      - master
-
-jobs:
-  build:
-    name: Build + Publish
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@master
-    - name: Set up Ruby 2.6
-      uses: actions/setup-ruby@v1
-      with:
-        version: 2.6.x
-
-    - name: Publish to GPR
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:github: Bearer ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
-      env:
-        GEM_HOST_API_KEY: ${{secrets.GPR_AUTH_TOKEN}}
-        OWNER: madkin10
-
-    - name: Publish to RubyGems
-      run: |
-        mkdir -p $HOME/.gem
-        touch $HOME/.gem/credentials
-        chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-        gem build *.gemspec
-        gem push *.gem
-      env:
-        GEM_HOST_API_KEY: ${{secrets.RUBYGEMS_AUTH_TOKEN}}