daigaku 0.0.1

data/spec/daigaku/terminal/output_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Daigaku::Terminal::Output do
+
+  subject do
+    require 'thor'
+    class Test < Thor
+      include Daigaku::Terminal::Output
+    end
+
+    Test.new
+  end
+
+  before do
+    allow($stdout).to receive(:puts) { |string| string }
+    allow($stdout).to receive(:print) { |string| string }
+  end
+
+  [
+    :say,
+    :empty_line,
+    :get,
+    :say_info,
+    :say_warning,
+    :get_command
+  ].each do |method|
+    it "has the private method #{method}" do
+      expect(subject.private_methods.include?(method)).to be_truthy
+    end
+  end
+
+  describe "::say" do
+    it "prints the prescribed output to the $stdout" do
+      line = "line"
+      expect($stdout).to receive(:puts).with("\t#{line}")
+      subject.send(:say, line)
+    end
+
+    it "adds the line start in case of multiline inputs" do
+      lines = "first line\nsecond line\nthird line\n"
+      out_lines = lines.split("\n").map {|l| "\t#{l}" }.join("\n")
+      expect($stdout).to receive(:puts).with(out_lines)
+      subject.send(:say, lines)
+    end
+  end
+
+  describe "::empty_line" do
+    it "prints an empty line to the $stdout" do
+      expect($stdout).to receive(:puts).with('')
+      subject.send(:empty_line)
+    end
+  end
+
+  describe "::get" do
+    it "prints a string to $stdout to get a line on $stdin" do
+      printed = 'printed'
+      received = 'received'
+
+      allow($stdin).to receive(:gets) { received }
+      expect($stdout).to receive(:print).with("\n\t#{printed} ")
+      expect($stdin).to receive(:gets)
+      subject.send(:get, printed)
+    end
+  end
+
+  describe "::say_info" do
+    it "prints the prescribed output to the $stdout" do
+      line = "line"
+      expect($stdout).to receive(:puts).exactly(4).times.with("")
+      expect($stdout).to receive(:puts).with("\t" + " ℹ #{line}".light_blue)
+      expect($stdout).to receive(:puts).twice.times.with("\t" + ('-' * 70).light_blue)
+      subject.send(:say_info, line)
+    end
+  end
+
+  describe "::say_warning" do
+    it "prints the prescribed output to the $stdout" do
+      line = "line"
+      expect($stdout).to receive(:puts).exactly(4).times.with("")
+      expect($stdout).to receive(:puts).with("\t" + "⚠  #{line}".light_red)
+      expect($stdout).to receive(:puts).twice.times.with("\t" + ('-' * 70).light_red)
+      subject.send(:say_warning, line)
+    end
+  end
+
+  describe "::get_command" do
+
+    before do
+      @correct_command = 'correct command'
+      @description = 'description'
+      allow($stdin).to receive(:gets).and_return(@correct_command)
+      allow(Kernel).to receive(:system) { '' }
+    end
+
+    it "prints a description" do
+      expect($stdout).to receive(:puts).once.with("\t#{@description}")
+      subject.send(:get_command, @correct_command, @description)
+    end
+
+    it "gets a command from the $stdin" do
+      expect($stdin).to receive(:gets)
+      subject.send(:get_command, @correct_command, @description)
+    end
+
+    context "with the right command typed in:" do
+      it "gets a specified command from the user" do
+        subject.send(:get_command, @correct_command, @description)
+      end
+    end
+
+    context "with a wrong command typed  in:" do
+      it "writed a hint" do
+        wrong_command = 'wrong command'
+        error = "This was something else. Try \"#{@correct_command}\"."
+        allow($stdin).to receive(:gets).and_return(wrong_command, @correct_command)
+
+        expect($stdout).to receive(:puts).once.with("\t#{error}")
+        subject.send(:get_command, @correct_command, @description)
+      end
+    end
+  end
+
+end

data/spec/daigaku/terminal/setup_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Daigaku::Terminal::Setup do
+
+  it { is_expected.to be_a Thor }
+  it { is_expected.to respond_to :list }
+  it { is_expected.to respond_to :set }
+  it { is_expected.to respond_to :init }
+
+end

data/spec/daigaku/terminal/solutions_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Daigaku::Terminal::Solutions do
+
+  it { is_expected.to be_a Thor }
+  it { is_expected.to respond_to :open }
+
+end

data/spec/daigaku/terminal/welcome_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Daigaku::Terminal::Welcome do
+
+  [:run, :about].each do |method|
+    it "has the singleton method ::#{method}" do
+      singleton_methods = Daigaku::Terminal::Welcome.singleton_methods
+      expect(singleton_methods.include?(method)).to be_truthy
+    end
+  end
+
+end

data/spec/daigaku/terminal_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Daigaku::Terminal do
+
+  it { is_expected.to respond_to :text }
+
+  describe "::load_text" do
+    it "loads a text from a file in the cli/texts" do
+      text = Daigaku::Terminal.text(:welcome)
+      expect(text).to be_a String
+    end
+  end
+
+end

data/spec/daigaku/test_example_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Daigaku::TestExample do
+
+    it { is_expected.to respond_to :description }
+    it { is_expected.to respond_to :status }
+    it { is_expected.to respond_to :message }
+
+  context "when passed:" do
+    let(:description) { test_passed_json_parsed[:examples].first[:description] }
+    let(:status) { test_passed_json_parsed[:examples].first[:status] }
+
+    subject { Daigaku::TestExample.new(description: description, status: status) }
+
+    it "has the prescribed description" do
+      expect(subject.description).to eq description
+    end
+
+    it "has the prescribed status" do
+      expect(subject.status).to eq status
+    end
+
+    it "has the prescribed message" do
+      expect(subject.message).to eq example_passed_message
+    end
+  end
+
+  context "when failed:" do
+    let(:description) { test_failed_json_parsed[:examples].first[:description] }
+    let(:status) { test_failed_json_parsed[:examples].first[:status] }
+    let(:message) { test_failed_json_parsed[:examples].first[:exception][:message] }
+
+    subject do
+      Daigaku::TestExample.new(
+        description: description,
+        status: status,
+        message: message
+      )
+    end
+
+    it "has the prescribed description" do
+      expect(subject.description).to eq description
+    end
+
+    it "has the prescribed status" do
+      expect(subject.status).to eq status
+    end
+
+    it "has the prescribed message" do
+      expect(subject.message).to eq message
+    end
+  end
+
+end

data/spec/daigaku/test_result_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Daigaku::TestResult do
+
+  subject { Daigaku::TestResult.new(test_passed_json) }
+
+  it { is_expected.to respond_to :example_count }
+  it { is_expected.to respond_to :failure_count }
+  it { is_expected.to respond_to :examples }
+  it { is_expected.to respond_to :passed? }
+  it { is_expected.to respond_to :summary }
+
+  context "with passed input:" do
+
+    subject { Daigaku::TestResult.new(test_passed_json) }
+
+    it "is marked passed" do
+      expect(subject.passed?).to be_truthy
+    end
+
+    it "has a default summary" do
+      expect(subject.summary).to eq test_passed_summary
+    end
+  end
+
+  context "with failed input:" do
+
+    subject { Daigaku::TestResult.new(test_failed_json) }
+
+    it "is not marked passed" do
+      expect(subject.passed?).to be_falsey
+    end
+
+    it "has the prescribed example count" do
+      example_count = test_failed_json_parsed[:summary][:example_count]
+      expect(subject.example_count).to eq example_count
+    end
+
+    it "has the prescribed failure count" do
+      failure_count = test_failed_json_parsed[:summary][:failure_count]
+      expect(subject.failure_count).to eq failure_count
+    end
+
+    describe "#examples" do
+      it "returns the prescribed number of examples" do
+        examples_count = test_failed_json_parsed[:examples].count
+        expect(subject.examples.count).to eq examples_count
+      end
+
+      it "returns examples of type Daigaku::TestExample" do
+        subject.examples.each do |example|
+          expect(example).to be_a Daigaku::TestExample
+        end
+      end
+
+      it "return examples with the prescribed info" do
+        subject.examples.each_with_index do |example, index|
+          description = test_failed_json_parsed[:examples][index][:full_description]
+          status = test_failed_json_parsed[:examples][index][:status]
+          exception = test_failed_json_parsed[:examples][index][:exception]
+          message = exception ? exception[:message] : example_passed_message
+
+          expect(example.description).to eq description
+          expect(example.status).to eq status
+          expect(example.message).to eq message
+        end
+      end
+    end
+
+    describe "#summary" do
+      it "returns a string having all example infos" do
+        subject.examples.each do |example|
+          expect(subject.summary).to include example.description
+          expect(subject.summary).to include example.message
+          expect(subject.summary).to include example.status
+        end
+      end
+    end
+  end
+
+end

data/spec/daigaku/test_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Daigaku::Test do
+
+  it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :run }
+
+  before(:all) do
+    prepare_solutions
+    Daigaku.config.solutions_path = solutions_basepath
+  end
+
+  let(:unit_path) { all_unit_dirs.first }
+  let(:test_path) { all_test_file_paths.first }
+
+  subject { Daigaku::Test.new(unit_path) }
+
+  it "has the appropriate path" do
+    expect(subject.path).to eq test_path
+  end
+
+  describe "#run" do
+    before do
+      course_name = course_dir_names.first
+      chapter_name = chapter_dir_names.first
+      unit_name = unit_dir_names.first
+      @code = available_solution(course_name, chapter_name, unit_name).code
+    end
+
+    it "returns a Daigaku::TestResult" do
+      expect(subject.run(@code)).to be_a Daigaku::TestResult
+    end
+
+    context "when passing" do
+      it "returns a passing result" do
+        expect(subject.run(@code).passed?).to be_truthy
+      end
+    end
+
+    context "when failing" do
+      it "returns a failing result" do
+        code = "print 'BYE WORLD'"
+        expect(subject.run(code).passed?).to be_falsey
+      end
+    end
+  end
+
+end

data/spec/daigaku/unit_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Daigaku::Unit do
+
+  it { is_expected.to respond_to :title }
+  it { is_expected.to respond_to :task }
+  it { is_expected.to respond_to :solution }
+  it { is_expected.to respond_to :reference_solution }
+  it { is_expected.to respond_to :mastered? }
+
+  let(:course_name) { course_dir_names.first }
+  let(:chapter_name) { chapter_dir_names.first }
+  let(:unit_name) { unit_dir_names.first }
+
+  subject { Daigaku::Unit.new(unit_dirs(course_name).first[0]) }
+
+  it "has the prescribed title" do
+    expect(subject.title).to eq unit_titles.first
+  end
+
+  describe "#task" do
+    it "returns an object of type Daigaku::Task" do
+      expect(subject.task).to be_a Daigaku::Task
+    end
+
+    it "returns the unit's appropriate task" do
+      task = available_task(course_name, chapter_name, unit_name).first
+      expect(subject.task.markdown).to eq task.markdown
+    end
+
+    it "lazy-loads the task" do
+      expect(subject.instance_variable_get(:@task)).to be_nil
+      subject.task
+      expect(subject.instance_variable_get(:@task)).not_to be_nil
+    end
+  end
+
+  describe "#reference_solution" do
+    it "returns an object of type Daigaku::ReferenceSolution" do
+      expect(subject.reference_solution).to be_a Daigaku::ReferenceSolution
+    end
+
+    it "returns the units appropriate predefined reference solution" do
+      reference_solution = available_reference_solution(course_name,
+                                                        chapter_name,
+                                                        unit_name).first
+      expect(subject.reference_solution.code).to eq reference_solution.code
+    end
+
+    it "lazy-loads the reference solution" do
+      expect(subject.instance_variable_get(:@reference_solution)).to be_nil
+      subject.reference_solution
+      expect(subject.instance_variable_get(:@reference_solution)).not_to be_nil
+    end
+  end
+
+  describe "#solution" do
+    it "returns an object of type Daigaku::Solution" do
+      expect(subject.solution).to be_a Daigaku::Solution
+    end
+
+    it "returns the units appropriate solution provided by the user" do
+      expect(subject.solution.code).to eq available_solution(course_name,
+                                                             chapter_name,
+                                                             unit_name).code
+    end
+
+    it "lazy-loads the reference solution" do
+      expect(subject.instance_variable_get(:@solution)).to be_nil
+      subject.solution
+      expect(subject.instance_variable_get(:@solution)).not_to be_nil
+    end
+  end
+
+  describe "#mastered?" do
+    it "returns false by default" do
+      expect(subject.mastered?).to be_falsey
+    end
+
+    it "returns true if the solution has been verified" do
+      allow_any_instance_of(Daigaku::Solution).to receive(:verified?) { true }
+      expect(subject.mastered?).to be_truthy
+    end
+  end
+end