command_kit 0.1.0 → 0.3.0

data/spec/os/linux_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+require 'command_kit/os/linux'
+
+describe CommandKit::OS::Linux do
+  module TestOSLinux
+    class TestCommand
+      include CommandKit::OS::Linux
+    end
+  end
+
+  let(:command_class) { TestOSLinux::TestCommand }
+
+  describe ".linux_distro" do
+    subject { command_class }
+
+    context "and the /etc/fedora-release file exists" do
+      before do
+        expect(File).to receive(:file?).with("/etc/fedora-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:fedora) }
+    end
+
+    context "and the /etc/redhat-release file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        expect(File).to receive(:file?).with("/etc/redhat-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:redhat) }
+    end
+
+    context "and the /etc/debian_version file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/redhat-release").and_return(false)
+        expect(File).to receive(:file?).with("/etc/debian_version").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:debian) }
+    end
+
+    context "and the /etc/SuSE-release file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/redhat-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/debian_version").and_return(false)
+        expect(File).to receive(:file?).with("/etc/SuSE-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:suse) }
+    end
+
+    context "and the /etc/arch-release file exists" do
+      before do
+        allow(File).to receive(:file?).with("/etc/fedora-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/redhat-release").and_return(false)
+        allow(File).to receive(:file?).with("/etc/debian_version").and_return(false)
+        allow(File).to receive(:file?).with("/etc/SuSE-release").and_return(false)
+        expect(File).to receive(:file?).with("/etc/arch-release").and_return(true)
+      end
+
+      it { expect(subject.linux_distro).to be(:arch) }
+    end
+  end
+
+  subject { command_class.new }
+
+  describe "#initialize" do
+    it "must default #linux_distro to self.class.linux_distro" do
+      expect(subject.linux_distro).to eq(command_class.linux_distro)
+    end
+
+    context "when the linux_distro: keyword is given" do
+      let(:linux_distro) { :suse }
+
+      subject { command_class.new(linux_distro: linux_distro) }
+
+      it "must set #linux_distro" do
+        expect(subject.linux_distro).to eq(linux_distro)
+      end
+    end
+  end
+
+  describe "#redhat_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
+    context "when #linux_distro is :redhat" do
+      let(:linux_distro) { :redhat }
+
+      it { expect(subject.redhat_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :redhat" do
+      let(:linux_distro) { :debian }
+
+      it { expect(subject.redhat_linux?).to be(false) }
+    end
+  end
+
+  describe "#fedora_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
+    context "when #linux_distro is :fedora" do
+      let(:linux_distro) { :fedora }
+
+      it { expect(subject.fedora_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :fedora" do
+      let(:linux_distro) { :debian }
+
+      it { expect(subject.fedora_linux?).to be(false) }
+    end
+  end
+
+  describe "#debian_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
+    context "when #linux_distro is :debian" do
+      let(:linux_distro) { :debian }
+
+      it { expect(subject.debian_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :fedora" do
+      let(:linux_distro) { :redhat }
+
+      it { expect(subject.debian_linux?).to be(false) }
+    end
+  end
+
+  describe "#suse_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
+    context "when #linux_distro is :suse" do
+      let(:linux_distro) { :suse }
+
+      it { expect(subject.suse_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :suse" do
+      let(:linux_distro) { :debian }
+
+      it { expect(subject.suse_linux?).to be(false) }
+    end
+  end
+
+  describe "#arch_linux?" do
+    subject { command_class.new(linux_distro: linux_distro) }
+
+    context "when #linux_distro is :arch" do
+      let(:linux_distro) { :arch }
+
+      it { expect(subject.arch_linux?).to be(true) }
+    end
+
+    context "when #linux_distro is not :arch" do
+      let(:linux_distro) { :debian }
+
+      it { expect(subject.arch_linux?).to be(false) }
+    end
+  end
+end

data/spec/os_spec.rb

@@ -2,45 +2,232 @@ require 'spec_helper'
 require 'command_kit/os'
 
 describe CommandKit::OS do
-  class TestOS
-    include CommandKit::OS
+  module TestOS
+    class TestCommand
+      include CommandKit::OS
+    end
   end
 
-  subject { TestOS.new }
+  let(:command_class) { TestOS::TestCommand }
+  subject { command_class.new }
+
+  describe ".os" do
+    subject { command_class }
 
-  describe "#linux?" do
     context "when RUBY_PLATFORM contains 'linux'" do
       before { stub_const('RUBY_PLATFORM','x86_64-linux') }
 
-      it { expect(subject.linux?).to be(true) }
+      it { expect(subject.os).to be(:linux) }
     end
 
-    context "when RUBY_PLATFORM does not contain 'linux'" do
+    context "when RUBY_PLATFORM contains 'darwin'" do
       before { stub_const('RUBY_PLATFORM','aarch64-darwin') }
 
+      it { expect(subject.os).to be(:macos) }
+    end
+
+    context "when RUBY_PLATFORM contains 'freebsd'" do
+      before { stub_const('RUBY_PLATFORM','x86_64-freebsd') }
+
+      it { expect(subject.os).to be(:freebsd) }
+    end
+
+    context "when RUBY_PLATFORM contains 'openbsd'" do
+      before { stub_const('RUBY_PLATFORM','x86_64-openbsd') }
+
+      it { expect(subject.os).to be(:openbsd) }
+    end
+
+    context "when RUBY_PLATFORM contains 'netbsd'" do
+      before { stub_const('RUBY_PLATFORM','x86_64-netbsd') }
+
+      it { expect(subject.os).to be(:netbsd) }
+    end
+
+    context "when Gem.win_platform? returns true" do
+      before do
+        stub_const('RUBY_PLATFORM','x86_64-mswin')
+
+        expect(Gem).to receive(:win_platform?).and_return(true)
+      end
+
+      it { expect(subject.os).to be(:windows) }
+    end
+  end
+
+  describe "#initialize" do
+    it "must default #os to self.class.os" do
+      expect(subject.os).to eq(command_class.os)
+    end
+
+    context "when initialized with the os: keyword" do
+      let(:os) { :netbsd }
+
+      subject { command_class.new(os: os) }
+
+      it "must set #os" do
+        expect(subject.os).to eq(os)
+      end
+    end
+  end
+
+  describe "#linux?" do
+    context "when #os is :linux" do
+      subject { command_class.new(os: :linux) }
+
+      it { expect(subject.linux?).to be(true) }
+    end
+
+    context "when #os is not :linux" do
+      subject { command_class.new(os: :windows) }
+
       it { expect(subject.linux?).to be(false) }
     end
   end
 
   describe "#macos?" do
-    context "when RUBY_PLATFORM contains 'darwin'" do
-      before { stub_const('RUBY_PLATFORM','aarch64-darwin') }
+    context "when #os is :macos" do
+      subject { command_class.new(os: :macos) }
 
       it { expect(subject.macos?).to be(true) }
     end
 
-    context "when RUBY_PLATFORM does not contain 'darwin'" do
-      before { stub_const('RUBY_PLATFORM','mswin') }
+    context "when #os is not :macos" do
+      subject { command_class.new(os: :windows) }
 
       it { expect(subject.macos?).to be(false) }
     end
   end
 
+  describe "#freebsd?" do
+    context "when #os is :freebsd" do
+      subject { command_class.new(os: :freebsd) }
+
+      it { expect(subject.freebsd?).to be(true) }
+    end
+
+    context "when #os is not :freebsd" do
+      subject { command_class.new(os: :windows) }
+
+      it { expect(subject.freebsd?).to be(false) }
+    end
+  end
+
+  describe "#openbsd?" do
+    context "when #os is :openbsd" do
+      subject { command_class.new(os: :openbsd) }
+
+      it { expect(subject.openbsd?).to be(true) }
+    end
+
+    context "when #os is not :openbsd" do
+      subject { command_class.new(os: :windows) }
+
+      it { expect(subject.openbsd?).to be(false) }
+    end
+  end
+
+  describe "#netbsd?" do
+    context "when #os is :netbsd" do
+      subject { command_class.new(os: :netbsd) }
+
+      it { expect(subject.netbsd?).to be(true) }
+    end
+
+    context "when #os is not :netbsd" do
+      subject { command_class.new(os: :windows) }
+
+      it { expect(subject.netbsd?).to be(false) }
+    end
+  end
+
+  describe "#bsd?" do
+    context "when #os is :freebsd" do
+      subject { command_class.new(os: :freebsd) }
+
+      it { expect(subject.bsd?).to be(true) }
+    end
+
+    context "when #os is :openbsd" do
+      subject { command_class.new(os: :openbsd) }
+
+      it { expect(subject.bsd?).to be(true) }
+    end
+
+    context "when #os is :netbsd" do
+      subject { command_class.new(os: :netbsd) }
+
+      it { expect(subject.bsd?).to be(true) }
+    end
+
+    context "when #os is :macos" do
+      subject { command_class.new(os: :macos) }
+
+      it { expect(subject.bsd?).to be(false) }
+    end
+
+    context "when #os is :linux" do
+      subject { command_class.new(os: :linux) }
+
+      it { expect(subject.bsd?).to be(false) }
+    end
+
+    context "when #os is :windows" do
+      subject { command_class.new(os: :windows) }
+
+      it { expect(subject.bsd?).to be(false) }
+    end
+  end
+
+  describe "#unix?" do
+    context "when #os is :freebsd" do
+      subject { command_class.new(os: :freebsd) }
+
+      it { expect(subject.unix?).to be(true) }
+    end
+
+    context "when #os is :openbsd" do
+      subject { command_class.new(os: :openbsd) }
+
+      it { expect(subject.unix?).to be(true) }
+    end
+
+    context "when #os is :netbsd" do
+      subject { command_class.new(os: :netbsd) }
+
+      it { expect(subject.unix?).to be(true) }
+    end
+
+    context "when #os is :macos" do
+      subject { command_class.new(os: :macos) }
+
+      it { expect(subject.unix?).to be(true) }
+    end
+
+    context "when #os is :linux" do
+      subject { command_class.new(os: :linux) }
+
+      it { expect(subject.unix?).to be(true) }
+    end
+
+    context "when #os is :windows" do
+      subject { command_class.new(os: :windows) }
+
+      it { expect(subject.unix?).to be(false) }
+    end
+  end
+
   describe "#windows?" do
-    it "must call Gem.win_platform?" do
-      expect(Gem).to receive(:win_platform?)
+    context "when #os is :windows" do
+      subject { command_class.new(os: :windows) }
+
+      it { expect(subject.windows?).to be(true) }
+    end
+
+    context "when #os is not :windows" do
+      subject { command_class.new(os: :linux) }
 
-      subject.windows?
+      it { expect(subject.windows?).to be(false) }
     end
   end
 end