daigaku 0.0.1

data/spec/daigaku/database_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Daigaku::Database do
+
+  subject { Daigaku::Database.send(:new) }
+
+  before do
+    Daigaku::Configuration.send(:new)
+
+    allow_any_instance_of(Daigaku::Configuration).to \
+      receive(:storage_file) { local_storage_file }
+  end
+
+  it { is_expected.to respond_to :get }
+  it { is_expected.to respond_to :set }
+  it { is_expected.to respond_to :file }
+
+  it "creates the database file(s) in the .daigaku directory on access" do
+    Daigaku::Database.call_an_arbitrary_method
+    expect(File.exist?(local_storage_file)).to be_truthy
+  end
+
+  it "allows setting arbitrary keys by setter methods" do
+    expect { Daigaku::Database.brownie = "brownie" }
+      .not_to raise_error
+  end
+
+  it "allows getting subsequently set keys" do
+    Daigaku::Database.carrots = "carrots"
+    expect(Daigaku::Database.carrots).to eq "carrots"
+  end
+
+  it "returns nil for not set keys" do
+    expect(Daigaku::Database.hamburger).to be_nil
+  end
+
+  it "raises an method missing errror for non getter/setter methods" do
+    expect { Daigaku::Database.arbitrary_method(1, 2) }
+      .to raise_error NoMethodError
+  end
+
+  it "responds to ::get" do
+    expect(Daigaku::Database).to respond_to :get
+  end
+
+  it "responds to ::set" do
+    expect(Daigaku::Database).to respond_to :set
+  end
+
+  it "responds to ::file" do
+    expect(Daigaku::Database).to respond_to :file
+  end
+
+  describe "::get" do
+    it "returns the value of the given key" do
+      toast = 'toast'
+      Daigaku::Database.toast = toast
+      expect(Daigaku::Database.get :toast).to eq toast
+    end
+  end
+
+  describe "::set" do
+    it "sets the value for the given key" do
+      juice = 'orange juice'
+      Daigaku::Database.set :juice, juice
+      expect(Daigaku::Database.juice).to eq juice
+    end
+  end
+
+  describe "::file" do
+    it "returns the storage file path" do
+      expect(Daigaku::Database.file).to eq Daigaku.config.storage_file
+    end
+  end
+
+  it "raises an error if the related getter for a setter is already defined" do
+    expect { Daigaku::Database.clone = 'defined' }.to raise_error
+  end
+end

data/spec/daigaku/generator_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Daigaku::Generator do
+
+  it { is_expected.to respond_to :scaffold }
+  it { is_expected.to respond_to :prepare }
+
+  subject { Daigaku::Generator.new }
+
+  before do
+    Daigaku.config.instance_variable_set(:@storage_file, local_storage_file)
+  end
+
+  describe "#scaffold" do
+    it "creates blank solution files for all available units" do
+      subject.scaffold(courses_basepath, solutions_basepath)
+
+      all_solution_file_paths.each do |file_path|
+        expect(File.exist?(file_path)).to be_truthy
+      end
+    end
+  end
+
+  describe "#prepare" do
+    context "with an existing solutions_path" do
+      before do
+        Daigaku.configure do |config|
+          config.solutions_path = solutions_basepath
+          config.courses_path = local_courses_path
+        end
+
+        subject.prepare
+      end
+
+      it "generates a '<basepath>/.daigaku/daigaku.db.yml' file" do
+        expect(File.exist?(local_storage_file)).to be_truthy
+      end
+
+      it "generates a '<basepath>/.daigaku/courses' folder" do
+        expect(Dir.exist?(local_courses_path)).to be_truthy
+      end
+
+      it "saves the current config info" do
+        expect(File.exist?(local_storage_file)).to be_truthy
+        expect(Daigaku::Database.courses_path).to eq local_courses_path
+        expect(Daigaku::Database.solutions_path).to eq solutions_basepath
+      end
+    end
+
+    context "with a missing solutions_path" do
+      before do
+        FileUtils.rm_r(solutions_basepath) if Dir.exist?(solutions_basepath)
+        base_path = File.dirname(Daigaku.config.courses_path)
+        @solutions_path =  File.join(base_path, 'solutions')
+
+        Daigaku.config.instance_variable_set(:@solutions_path, nil)
+        Daigaku.configure { |config| config.courses_path = local_courses_path }
+
+        subject.prepare
+      end
+
+      it "generates a 'solutions' path on the base directory as the courses" do
+        expect(Dir.exist?(@solutions_path)).to be_truthy
+      end
+
+      it "generates a '<basepath>/.daigaku/daigaku.db.yml' file" do
+        expect(File.exist?(local_storage_file)).to be_truthy
+      end
+
+      it "generates a '<basepath>/.daigaku/courses' folder" do
+        expect(Dir.exist?(local_courses_path)).to be_truthy
+      end
+
+      it "saves the current config info" do
+        expect(File.exist?(local_storage_file)).to be_truthy
+        expect(Daigaku::Database.courses_path).to eq local_courses_path
+        expect(Daigaku::Database.solutions_path).to eq @solutions_path
+      end
+    end
+  end
+
+end

data/spec/daigaku/loading/chapters_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Daigaku::Loading::Chapters do
+
+  let(:subjects) { Daigaku::Loading::Chapters.load(course_dirs.first) }
+
+  it "has the prescribed number of chapters" do
+    expect(subjects.count).to eq available_chapters(course_dirs.first).count
+  end
+
+  it "loads the available chapters" do
+    subjects.each_with_index do |chapter, index|
+      expect(chapter.title).to eq chapter_titles[index]
+    end
+  end
+end

data/spec/daigaku/loading/courses_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Daigaku::Loading::Courses do
+
+  let(:subjects) { Daigaku::Loading::Courses.load(courses_basepath) }
+
+  it "has the prescribed number of courses" do
+    expect(subjects.count).to eq available_courses.count
+  end
+
+  it "loads the available courses" do
+    subjects.each_with_index do |course, index|
+      expect(course.title).to eq course_titles[index]
+    end
+  end
+end

data/spec/daigaku/loading/units_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Daigaku::Loading::Units do
+
+  let(:course_name) { course_dir_names.first }
+  let(:chapter_path) { chapter_dirs(course_name).first }
+  let(:chapter_name) { File.basename(chapter_path) }
+
+  let(:subjects) { Daigaku::Loading::Units.load(chapter_path) }
+
+  it "has the prescribed number of units" do
+    units_count = available_units(course_name, chapter_name).count
+    expect(subjects.count).to eq units_count
+  end
+
+  it "loads the available units" do
+    subjects.each_with_index do |unit, index|
+      expect(unit.title).to eq unit_titles[index]
+    end
+  end
+end

data/spec/daigaku/reference_solution_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Daigaku::ReferenceSolution do
+
+  it { is_expected.to respond_to :code }
+  it { is_expected.to respond_to :path }
+
+  let(:unit_path) do
+    course_name = course_dir_names.first
+    unit_dirs(course_name)[0].first
+  end
+
+  subject { Daigaku::ReferenceSolution.new(unit_path) }
+
+  it "has the prescribed path" do
+    path = File.join(unit_path, reference_solution_name)
+    expect(subject.path).to eq path
+  end
+
+  it "has the prescribed code" do
+    expect(subject.code).to eq solution_content
+  end
+end

data/spec/daigaku/solution_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Daigaku::Solution do
+
+  it { is_expected.to respond_to :code }
+  it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :verify! }
+  it { is_expected.to respond_to :verified? }
+  it { is_expected.to respond_to :errors }
+
+  before(:all) do
+    prepare_solutions
+    Daigaku.config.solutions_path = solutions_basepath
+  end
+
+  let(:solution_path) { all_solution_file_paths.first }
+  let(:unit_path) { all_unit_dirs.first }
+
+  subject { Daigaku::Solution.new(unit_path) }
+
+  it "has the prescribed solution path from the given unit path" do
+    expect(subject.path).to eq solution_path
+  end
+
+  it "has the prescribed code" do
+    expect(subject.code).to eq solution_content
+  end
+
+  it "loads the verified state from the database on creation" do
+    Daigaku::Solution.new(unit_path).verify!
+    solution = Daigaku::Solution.new(unit_path)
+
+    expect(solution).to be_verified
+  end
+
+  context "Verification" do
+    describe "#verify!" do
+      it "returns a TestResult" do
+        expect(subject.verify!).to be_a Daigaku::TestResult
+      end
+
+      it "sets @verified true if Test passed" do
+        Daigaku::Database.set(subject.path, false)
+        solution = Daigaku::Solution.new(unit_path)
+
+        expect(solution.instance_variable_get(:@verified)).to be_falsey
+        solution.verify!
+        expect(solution.instance_variable_get(:@verified)).to be_truthy
+      end
+
+      it "sets the solution's state in the database to verified if passed" do
+        subject.verify!
+        mastered = Daigaku::Database.get(subject.path)
+
+        expect(mastered).to be_truthy
+      end
+
+      it "sets the solution's state in the database to unverified unless passed" do
+        subject.instance_variable_set(:@code, 'puts "I ❤ Daigaku!"')
+        subject.verify!
+        mastered = Daigaku::Database.get(subject.path)
+
+        expect(mastered).to be_falsey
+      end
+    end
+
+    describe "#verified?" do
+      it "is false by default" do
+        expect(subject.verified?).to be_falsey
+      end
+
+      it "returns true if #verify! passed" do
+        subject.verify!
+        expect(subject.verified?).to be_truthy
+      end
+    end
+  end
+
+end

data/spec/daigaku/task_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Daigaku::Task do
+
+  it { is_expected.to respond_to :markdown }
+  it { is_expected.to respond_to :path }
+
+  let(:unit_path) do
+    course_name = course_dir_names.first
+    unit_dirs(course_name)[0].first
+  end
+
+  subject { Daigaku::Task.new(unit_path) }
+
+  it "has the prescribed path" do
+    path = File.join(unit_path, task_name)
+    expect(subject.path).to eq path
+  end
+
+  it "has the prescribed markdown" do
+    expect(subject.markdown).to eq task_file_content
+  end
+end

data/spec/daigaku/terminal/cli_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Daigaku::Terminal::CLI do
+
+  it { is_expected.to be_a Thor }
+  it { is_expected.to respond_to :about }
+  it { is_expected.to respond_to :welcome }
+  it { is_expected.to respond_to :scaffold }
+  it { is_expected.to respond_to :learn }
+  it { is_expected.to respond_to :courses }
+  it { is_expected.to respond_to :solutions }
+  it { is_expected.to respond_to :setup }
+
+  describe "#learn" do
+    it "starts the daigaku terminal app if there are courses" do
+      allow(Daigaku::Loading::Courses).to receive(:load) { [1] }
+      allow(Daigaku).to receive(:start) { true }
+      expect(Daigaku).to receive(:start)
+
+      subject.learn
+    end
+
+    it "does not start the daigaku terminal app if there are no courses" do
+      suppress_print_out
+      allow(Daigaku::Loading::Courses).to receive(:load) { [] }
+      allow(Daigaku).to receive(:start) { true }
+      expect(Daigaku).not_to receive(:start)
+
+      subject.learn
+    end
+  end
+
+  describe "#welcome" do
+    it "runs the welcome routine" do
+      allow(Daigaku::Terminal::Welcome).to receive(:run) { true }
+      expect(Daigaku::Terminal::Welcome).to receive(:run).once
+
+      subject.welcome
+    end
+  end
+
+  describe "#scaffold" do
+    it "runs the scaffolding" do
+      allow($stdout).to receive(:puts) {}
+      allow_any_instance_of(Daigaku::Generator).to receive(:scaffold) { true }
+      expect_any_instance_of(Daigaku::Generator).to receive(:scaffold).once
+
+      subject.scaffold
+    end
+  end
+end

data/spec/daigaku/terminal/courses_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Daigaku::Terminal::Courses do
+
+  before { suppress_print_out }
+
+  it { is_expected.to be_a Thor }
+
+  describe "commands" do
+    [:list, :download].each do |method|
+      it { is_expected.to respond_to method }
+    end
+  end
+
+  describe "#download" do
+
+    before do
+      Daigaku.config.courses_path = local_courses_path
+
+      @zip_file_name = "repo.zip"
+      @file_content = prepare_download(@zip_file_name)
+      @url = "https://example.com/#{@zip_file_name}"
+
+      stub_request(:get, @url)
+        .with(headers: {
+          'Accept' => '*/*',
+          'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+          'User-Agent' => 'Ruby'
+          })
+        .to_return(status: 200, body: @file_content, headers: {})
+    end
+
+    after { cleanup_download(@zip_file_name) }
+
+    it "downloads the file from a given url" do
+      expect{ subject.download(@url) }.not_to raise_error
+    end
+
+    it "creates a new courses folder in the daigaku courses directory" do
+      target_path = File.join(Daigaku.config.courses_path, File.basename(course_dirs.first))
+
+      dirs = Dir[File.join(Daigaku.config.courses_path, '**')]
+      puts "target_path: #{target_path}"
+      puts dirs.to_s
+
+      expect(dirs.include?(target_path)).to be_truthy
+    end
+
+    it "raises an error if param is no url" do
+      expect(subject).to receive(:say_warning)
+      subject.download('no-url')
+    end
+
+    it "raises an error if param is no url to a zip file" do
+      expect(subject).to receive(:say_warning)
+      subject.download('http://exmaple.com/something-else')
+    end
+  end
+
+end