ronin-repos 0.1.0.beta1 → 0.1.1

data/spec/repository_spec.rb

@@ -1,415 +0,0 @@
-require 'spec_helper'
-require 'ronin/repos/repository'
-
-describe Ronin::Repos::Repository do
-  let(:fixtures_dir) { File.expand_path(File.join(__dir__,'fixtures')) }
-
-  let(:name) { 'repo1' }
-  let(:path) { File.join(fixtures_dir,'cache',name) }
-
-  subject { described_class.new(path) }
-
-  describe "#initialize" do
-    it "must set #path" do
-      expect(subject.path).to eq(path)
-    end
-
-    it "must set #name based on #path" do
-      expect(subject.name).to eq(File.basename(path))
-    end
-
-    context "when the path does not exist" do
-      let(:path) { '/path/does/not/exist' }
-
-      it do
-        expect {
-          described_class.new(path)
-        }.to raise_error(RepositoryNotFound,"repository does not exist: #{path.inspect}")
-      end
-    end
-
-    context "when the path is not a directory" do
-      let(:path) { __FILE__ }
-
-      it do
-        expect {
-          described_class.new(path)
-        }.to raise_error(RepositoryNotFound,"path is not a directory: #{path.inspect}")
-      end
-    end
-  end
-
-  describe ".clone" do
-    let(:uri)  { 'https://github.com/example/repo.git' }
-
-    subject { described_class }
-
-    it "must call `git clone` the URI to the given path and return a Repository" do
-      expect(subject).to receive(:system).with(
-        'git', 'clone', uri, path
-      ).and_return(true)
-
-      repo = subject.clone(uri,path)
-
-      expect(repo).to be_kind_of(described_class)
-      expect(repo.path).to eq(path)
-    end
-
-    context "when a depth: keyword argument is given" do
-      let(:depth) { 1 }
-
-      it "must `git clone --depth` with the given depth and URI to the given path)" do
-        expect(subject).to receive(:system).with(
-          'git', 'clone', '--depth', depth.to_s, uri, path
-        ).and_return(true)
-
-        subject.clone(uri,path, depth: depth)
-      end
-    end
-
-    context "when system() returns nil" do
-      it do
-        allow(subject).to receive(:system).and_return(nil)
-
-        expect {
-          subject.clone(uri,path)
-        }.to raise_error(CommandNotInstalled,"git is not installed")
-      end
-    end
-
-    context "when system() returns false" do
-      it do
-        allow(subject).to receive(:system).and_return(false)
-
-        expect {
-          subject.clone(uri,path)
-        }.to raise_error(CommandFailed,"command failed: git clone #{uri} #{path}")
-      end
-    end
-  end
-
-  describe ".install" do
-    let(:uri)  { 'https://github.com/example/repo.git' }
-
-    subject { described_class }
-
-    it "must `git clone` the URI and the given path and return a Repository" do
-      expect(subject).to receive(:system).with(
-        'git', 'clone', uri, path
-      ).and_return(true)
-
-      repo = subject.install(uri,path)
-
-      expect(repo).to be_kind_of(described_class)
-      expect(repo.path).to eq(path)
-    end
-
-    context "when the branch: keyword argument is given" do
-      let(:branch) { 'foo' }
-
-      it "must `git clone` the URI to the given path and then `git checkout` the branch)" do
-        expect(subject).to receive(:system).with(
-          'git', 'clone', uri, path
-        ).and_return(true)
-
-        expect_any_instance_of(described_class).to receive(:system).with(
-          'git', 'checkout', branch
-        ).and_return(true)
-
-        subject.install(uri,path, branch: branch)
-      end
-    end
-
-    context "when the tag: keyword argument is given" do
-      let(:tag) { 'v1.0.0' }
-
-      it "must `git clone` the URI to the given path and then `git checkout` the tag" do
-        expect(subject).to receive(:system).with(
-          'git', 'clone', uri, path
-        ).and_return(true)
-
-        expect_any_instance_of(described_class).to receive(:system).with(
-          'git', 'checkout', tag
-        ).and_return(true)
-
-        subject.install(uri,path, tag: tag)
-      end
-    end
-  end
-
-  describe "#pull" do
-    it "must `git pull` from 'origin'" do
-      expect(subject).to receive(:system).with(
-        'git', 'pull', 'origin'
-      ).and_return(true)
-
-      subject.pull
-    end
-
-    context "when the remote: keyword argument is given" do
-      let(:remote) { :backup }
-
-      it "must `git pull` from the given remote" do
-        expect(subject).to receive(:system).with(
-          'git', 'pull', remote.to_s
-        ).and_return(true)
-
-        subject.pull(remote: remote)
-      end
-    end
-
-    context "when the branch: keyword argument is given" do
-      let(:branch) { 'foo' }
-
-      it "must `git pull` from 'origin' and the given branch" do
-        expect(subject).to receive(:system).with(
-          'git', 'pull', 'origin', branch
-        ).and_return(true)
-
-        subject.pull(branch: branch)
-      end
-    end
-
-    context "when the `tags: true` is given" do
-      it "must `git pull` from 'origin' and pull down any tags" do
-        expect(subject).to receive(:system).with(
-          'git', 'pull', '--tags', 'origin'
-        ).and_return(true)
-
-        subject.pull(tags: true)
-      end
-    end
-
-    context "when system() returns nil" do
-      it do
-        allow(subject).to receive(:system).and_return(nil)
-
-        expect {
-          subject.pull
-        }.to raise_error(CommandNotInstalled,"git is not installed")
-      end
-    end
-
-    context "when system() returns false" do
-      it do
-        allow(subject).to receive(:system).and_return(false)
-
-        expect {
-          subject.pull
-        }.to raise_error(CommandFailed,"command failed: git pull origin")
-      end
-    end
-  end
-
-  describe "#checkout" do
-    let(:branch) { 'foo' }
-
-    it "must `git checkout` the given branch" do
-      expect(subject).to receive(:system).with(
-        'git', 'checkout', branch
-      ).and_return(true)
-
-      subject.checkout(branch)
-    end
-
-    context "when system() returns nil" do
-      it do
-        allow(subject).to receive(:system).and_return(nil)
-
-        expect {
-          subject.checkout(branch)
-        }.to raise_error(CommandNotInstalled,"git is not installed")
-      end
-    end
-
-    context "when system() returns false" do
-      it do
-        allow(subject).to receive(:system).and_return(false)
-
-        expect {
-          subject.checkout(branch)
-        }.to raise_error(CommandFailed,"command failed: git checkout #{branch}")
-      end
-    end
-  end
-
-  describe "#update" do
-    it "must `git pull` from 'origin' and pull down any tags" do
-      expect(subject).to receive(:system).with(
-        'git', 'pull', '--tags', 'origin'
-      ).and_return(true)
-
-      subject.update
-    end
-
-    context "when the branch: keyword argument is given" do
-      let(:branch) { 'foo' }
-
-      it "must `git pull` from 'origin' and the given branch and then `git checkout` the branch" do
-        expect(subject).to receive(:system).with(
-          'git', 'pull', 'origin', branch
-        ).and_return(true)
-
-        expect(subject).to receive(:system).with(
-          'git', 'checkout', branch
-        ).and_return(true)
-
-        subject.update(branch: branch)
-      end
-    end
-
-    context "when the tag: keyword argument is given" do
-      let(:tag) { 'v1.0.0' }
-
-      it "must `git pull --tags` from 'origin' and then `git checkout` the given tag" do
-        expect(subject).to receive(:system).with(
-          'git', 'pull', '--tags', 'origin'
-        ).and_return(true)
-
-        expect(subject).to receive(:system).with(
-          'git', 'checkout', tag
-        ).and_return(true)
-
-        subject.update(tag: tag)
-      end
-    end
-  end
-
-  describe "#delete" do
-    it "must call FileUtils.rm_rf on the path" do
-      expect(FileUtils).to receive(:rm_rf).with(path)
-
-      subject.delete
-    end
-  end
-
-  describe "#join" do
-    let(:relative_path) { 'file1.txt' }
-
-    it "must return the absolute path with respect to the repository" do
-      expect(subject.join(relative_path)).to eq(
-        File.join(path,relative_path)
-      )
-    end
-  end
-
-  describe "#has_file?" do
-    context "when the repository contains the file" do
-      let(:relative_path) { 'file1.txt' }
-
-      it "must return the absolute path to the file" do
-        expect(subject.has_file?(relative_path)).to be(true)
-      end
-    end
-
-    context "when the relative path does not exist within the repository" do
-      let(:relative_path) { 'does/not/exist.txt' }
-
-      it "must return false" do
-        expect(subject.has_file?(relative_path)).to be(false)
-      end
-    end
-  end
-
-  describe "#has_directory?" do
-    context "when the repository contains the directory" do
-      let(:relative_path) { 'dir' }
-
-      it "must return the absolute path to the directory" do
-        expect(subject.has_directory?(relative_path)).to be(true)
-      end
-    end
-
-    context "when the relative path does not exist within the repository" do
-      let(:relative_path) { 'does/not/exist' }
-
-      it "must return false" do
-        expect(subject.has_directory?(relative_path)).to be(false)
-      end
-    end
-  end
-
-  describe "#find_file" do
-    context "when the relative path exists within the repository" do
-      let(:relative_path) { 'file1.txt' }
-
-      it "must return the absolute path to the file" do
-        expect(subject.find_file(relative_path)).to eq(
-          File.join(path,relative_path)
-        )
-      end
-    end
-
-    context "when the relative path does not exist within the repository" do
-      let(:relative_path) { 'does/not/exist.txt' }
-
-      it "must return nil" do
-        expect(subject.find_file(relative_path)).to be(nil)
-      end
-    end
-  end
-
-  describe "#glob" do
-    context "when the pattern matches files within the repository" do
-      let(:pattern) { 'dir/*.txt' }
-
-      it "must return the absolute path to the file" do
-        expect(subject.glob(pattern)).to eq(
-          Dir[File.join(path,pattern)]
-        )
-      end
-
-      context "when a block is given" do
-        it "must yield the matching absolute paths" do
-          expect { |b|
-            subject.glob(pattern,&b)
-          }.to yield_successive_args(
-            *Dir[File.join(path,pattern)]
-          )
-        end
-      end
-    end
-
-    context "when the relative path does not exist within the repository" do
-      let(:pattern) { 'does/not/exist/*.txt' }
-
-      it "must return []" do
-        expect(subject.glob(pattern)).to eq([])
-      end
-
-      context "when a block is given" do
-        it "must not yield" do
-          expect { |b|
-            subject.glob(pattern,&b)
-          }.to_not yield_control
-        end
-      end
-    end
-  end
-
-  describe "#list_files" do
-    context "when given no arguments" do
-      it "must list every file within the repository's directory" do
-        expect(subject.list_files).to eq(
-          %w[
-            dir/file1.txt
-            file1.txt
-            file2.txt
-          ]
-        )
-      end
-    end
-
-    context "when given a glob pattern" do
-      it "must list only the files that match the glob pattern" do
-        expect(subject.list_files('dir/*.txt')).to eq(%w[dir/file1.txt])
-      end
-    end
-  end
-
-  describe "#to_s" do
-    it "must return the repository name" do
-      expect(subject.to_s).to eq(name)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,6 +0,0 @@
-require 'rspec'
-require 'simplecov'
-SimpleCov.start
-
-require 'ronin/repos/version'
-include Ronin::Repos