daigaku 0.0.2 → 0.1.0

data/spec/daigaku/configuration_spec.rb

@@ -49,43 +49,43 @@ describe Daigaku::Configuration do
   end
 
   describe "#storage_path" do
-    it "returns the appropriate path to the storge file" do
+    it "returns the appropriate path to the storage file" do
       expect(subject.storage_file).to eq local_storage_file
     end
   end
 
   describe "#save" do
-    it "saves the configured courses path to the daigaku database" do
+    it "saves the configured courses path to the daigaku store" do
       subject.courses_path = local_courses_path
       subject.save
 
-      expect(Daigaku::Database.courses_path).to eq local_courses_path
+      expect(QuickStore.store.courses_path).to eq local_courses_path
     end
 
-    it "saves the configured solution_path to the daigaku database" do
+    it "saves the configured solution_path to the daigaku store" do
       path = File.join(test_basepath, 'test_solutions')
       FileUtils.makedirs(path)
       subject.solutions_path = path
       subject.save
 
-      expect(Daigaku::Database.solutions_path).to eq path
+      expect(QuickStore.store.solutions_path).to eq path
     end
 
     it "does not save the storage file path" do
       subject.save
-      expect(Daigaku::Database.storage_file).to be_nil
+      expect(QuickStore.store.storage_file).to be_nil
     end
   end
 
   describe "#import!" do
-    context "with non-existent daigaku database entries:" do
+    context "with non-existent daigaku store entries:" do
       before  do
         FileUtils.rm(local_storage_file) if File.exist?(local_storage_file)
       end
 
       it "uses the default configuration" do
-        Daigaku::Database.courses_path = nil
-        Daigaku::Database.solutions_path = nil
+        QuickStore.store.courses_path = nil
+        QuickStore.store.solutions_path = nil
         subject.instance_variable_set(:@courses_path, local_courses_path)
 
         loaded_config = subject.import!
@@ -96,12 +96,12 @@ describe Daigaku::Configuration do
       end
     end
 
-    context "with existing daigaku database file:" do
+    context "with existing daigaku storage file:" do
       it "returns a Daigaku::Configuration" do
         expect(subject.import!).to be_a Daigaku::Configuration
       end
 
-      it "loads the daigaku database entries into the configuration" do
+      it "loads the daigaku store entries into the configuration" do
         wanted_courses_path = "/courses/path"
         wanted_solutions_path = solutions_basepath
         temp_solutions_path = File.join(solutions_basepath, 'temp')

data/spec/daigaku/congratulator_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Daigaku::Congratulator do
+
+  it "responds to #message" do
+    expect(Daigaku::Congratulator).to respond_to :message
+  end
+
+  describe "#message" do
+    it "returns a string" do
+      expect(Daigaku::Congratulator.message).to be_a String
+    end
+
+    it "returns a random congratulation method" do
+      messages = 1.upto(10).map { |i| Daigaku::Congratulator.message }
+      expect(messages.uniq.count).to be > 1
+    end
+
+    it "receives the congratulation texts from a Terminal text" do
+      expect(Daigaku::Terminal).to receive(:text).with(:congratulations) { '' }
+      Daigaku::Congratulator.message
+    end
+  end
+end

data/spec/daigaku/course_spec.rb

@@ -72,4 +72,22 @@ describe Daigaku::Course do
       expect(subject.mastered?).to be false
     end
   end
+
+  describe "#key" do
+    it "returns the courses store key for the given key name" do
+      allow(subject).to receive(:title) { '1-Course title' }
+      key = "courses/course_title/some_key"
+      expect(subject.key('1-some Key')).to eq key
+    end
+  end
+
+  describe "#author" do
+    it "returns the author of Github courses form the store" do
+      author = 'author'
+      QuickStore.store.set(subject.key(:author), author)
+
+      course = Daigaku::Course.new(course_path)
+      expect(course.author).to eq author
+    end
+  end
 end

data/spec/daigaku/generator_spec.rb

@@ -42,8 +42,8 @@ describe Daigaku::Generator do
 
       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
+        expect(QuickStore.store.courses_path).to eq local_courses_path
+        expect(QuickStore.store.solutions_path).to eq solutions_basepath
       end
     end
 
@@ -73,8 +73,8 @@ describe Daigaku::Generator do
 
       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
+        expect(QuickStore.store.courses_path).to eq local_courses_path
+        expect(QuickStore.store.solutions_path).to eq @solutions_path
       end
     end
   end

data/spec/daigaku/github_client_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Daigaku::GithubClient do
+
+  describe "#master_zip_url" do
+    it "returns the url to the master zip file for the given github repo" do
+      url = "https://github.com/a/b/archive/master.zip"
+      expect(Daigaku::GithubClient.master_zip_url('a/b')).to eq url
+    end
+  end
+
+  describe "#updated_at" do
+    it "fetches the updated_at timestamp from the Github API" do
+      expected_timestamp = "2015-10-21T12:00:00Z"
+      response = { updated_at: expected_timestamp }.to_json
+      url = "https://api.github.com/repos/a/b"
+
+      stub_request(:get, url)
+        .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+        .to_return(status: 200, body: response, headers: {})
+
+      timestamp = Daigaku::GithubClient.updated_at('a/b')
+
+      expect(timestamp).to eq expected_timestamp
+    end
+  end
+
+  describe "#updated?" do
+    before do
+      @received_timestamp = "2015-10-21T12:00:00Z"
+      response = { updated_at: @received_timestamp }.to_json
+      url = "https://api.github.com/repos/a/b"
+
+      stub_request(:get, url)
+        .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+        .to_return(status: 200, body: response, headers: {})
+    end
+
+    it "returns true if content was pushed to the Github repo" do
+      QuickStore.store.set('courses/b/updated_at', "2015-10-21T11:59:59Z")
+      expect(Daigaku::GithubClient.updated?('a/b')).to be_truthy
+    end
+
+    it "returns false if no content was pushed to the Github repo" do
+      QuickStore.store.set('courses/b/updated_at', @received_timestamp)
+      expect(Daigaku::GithubClient.updated?('a/b')).to be_falsey
+    end
+
+    it "returns false if param is nil" do
+      expect(Daigaku::GithubClient.updated?(nil)).to be_falsey
+    end
+  end
+end

data/spec/daigaku/reference_solution_spec.rb

@@ -4,6 +4,7 @@ describe Daigaku::ReferenceSolution do
 
   it { is_expected.to respond_to :code }
   it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :code_lines }
 
   let(:unit_path) do
     course_name = course_dir_names.first
@@ -17,7 +18,24 @@ describe Daigaku::ReferenceSolution do
     expect(subject.path).to eq path
   end
 
-  it "has the prescribed code" do
-    expect(subject.code).to eq solution_content
+  describe "#code" do
+    it "has the prescribed code" do
+      expect(subject.code).to eq solution_content
+    end
+
+    it "returns an empty string if the code is not available" do
+      subject.instance_variable_set(:@code, nil)
+      expect(subject.code).to eq ""
+    end
+  end
+
+
+  describe "#code_lines" do
+    it "returns the code split into lines" do
+      lines = ['muffin = "sweet"', 'hamburger = "mjummy"']
+      allow(subject).to receive(:code) { lines.join("\n") }
+
+      expect(subject.code_lines).to eq lines
+    end
   end
 end

data/spec/daigaku/solution_spec.rb

@@ -26,13 +26,20 @@ describe Daigaku::Solution do
     expect(subject.code).to eq solution_content
   end
 
-  it "loads the verified state from the database on creation" do
+  it "loads the verified state from the store on creation" do
     Daigaku::Solution.new(unit_path).verify!
     solution = Daigaku::Solution.new(unit_path)
 
     expect(solution).to be_verified
   end
 
+  describe "#store_key" do
+    it "returns the appropriate key string for the solution" do
+      key = "verified/course_a/chapter_a/unit_a"
+      expect(subject.store_key).to eq key
+    end
+  end
+
   context "Verification" do
     describe "#verify!" do
       it "returns a TestResult" do
@@ -40,7 +47,7 @@ describe Daigaku::Solution do
       end
 
       it "sets @verified true if Test passed" do
-        Daigaku::Database.set(subject.path, false)
+        QuickStore.store.set(subject.store_key, false)
         solution = Daigaku::Solution.new(unit_path)
 
         expect(solution.instance_variable_get(:@verified)).to be_falsey
@@ -48,17 +55,17 @@ describe Daigaku::Solution do
         expect(solution.instance_variable_get(:@verified)).to be_truthy
       end
 
-      it "sets the solution's state in the database to verified if passed" do
+      it "sets the solution's state in the store to verified if passed" do
         subject.verify!
-        mastered = Daigaku::Database.get(subject.path)
+        mastered = QuickStore.store.get(subject.store_key)
 
         expect(mastered).to be_truthy
       end
 
-      it "sets the solution's state in the database to unverified unless passed" do
+      it "sets the solution's state in the store to unverified unless passed" do
         subject.instance_variable_set(:@code, 'puts "I ❤ Daigaku!"')
         subject.verify!
-        mastered = Daigaku::Database.get(subject.path)
+        mastered = QuickStore.store.get(subject.store_key)
 
         expect(mastered).to be_falsey
       end

data/spec/daigaku/storeable_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Daigaku::Storeable do
+
+  it "responds to ::key" do
+    expect(Daigaku::Storeable).to respond_to :key
+  end
+
+  describe '::key' do
+    it "creates a store key from the given string" do
+      key = Daigaku::Storeable.key('1-_Raw content-Title')
+      expect(key).to eq 'raw_content_title'
+    end
+
+    it "creates a cleaned up store key from a given path string" do
+      key = Daigaku::Storeable.key('path/to/the/1-_Raw content string')
+      expect(key).to eq 'path/to/the/raw_content_string'
+    end
+
+    it "creates a prefixed key when a prefix option is given" do
+      key = Daigaku::Storeable.key('1-_Raw content-Title', prefix: 'courses')
+      expect(key).to eq 'courses/raw_content_title'
+    end
+
+    it "creates a suffixed key if a suffix option is given" do
+      key = Daigaku::Storeable.key('1-_Raw content-Title', suffix: '1-author')
+      expect(key).to eq 'raw_content_title/author'
+    end
+
+    it "creates a multi suffixed key if a suffixes option is given" do
+      key = Daigaku::Storeable.key('1-_Raw content-Title', suffixes: ['meta', '1-author'] )
+      expect(key).to eq 'raw_content_title/meta/author'
+    end
+  end
+end

data/spec/daigaku/terminal/courses_spec.rb

@@ -13,7 +13,6 @@ describe Daigaku::Terminal::Courses do
   end
 
   describe "#download" do
-
     before do
       Daigaku.config.courses_path = local_courses_path
 
@@ -28,6 +27,10 @@ describe Daigaku::Terminal::Courses do
           'User-Agent' => 'Ruby'
           })
         .to_return(status: 200, body: @file_content, headers: {})
+
+      stub_request(:get, "https://api.github.com/repos/daigaku-ruby/Get_started_with_Ruby")
+        .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+        .to_return(status: 200, body: "{}", headers: {})
     end
 
     after { cleanup_download(@zip_file_name) }
@@ -38,11 +41,7 @@ describe Daigaku::Terminal::Courses do
 
     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
 
@@ -55,6 +54,217 @@ describe Daigaku::Terminal::Courses do
       expect(subject).to receive(:say_warning)
       subject.download('http://exmaple.com/something-else')
     end
+
+    describe "stores download data:" do
+      before do
+        @github_url = "https://github.com/user/course_a/archive/master.zip"
+
+        stub_request(:get, @github_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: {})
+
+        stub_request(:get, "https://api.github.com/repos/course_a/repo")
+          .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+          .to_return(status: 200, body: "{}", headers: {})
+      end
+
+      it "stores the course's author for courses from Github" do
+        subject.download(@github_url)
+        store_key = 'courses/course_a/author'
+        expect(QuickStore.store.get(store_key)).to eq 'user'
+      end
+
+      it "stores the course's repo for courses from Github" do
+        subject.download(@github_url)
+        store_key = 'courses/course_a/github'
+        expect(QuickStore.store.get(store_key)).to eq 'user/course_a'
+      end
+
+      it "stores the downloading timestamp" do
+        time = Time.now
+        allow(Time).to receive(:now) { time }
+        subject.download(@url)
+        expect(QuickStore.store.get('courses/course_a/updated_at')).to eq time.to_s
+      end
+
+      it "stores the course's download url" do
+        subject.download(@url)
+        expect(QuickStore.store.get('courses/course_a/url')).to eq @url
+      end
+    end
+  end
+
+  describe '#update' 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: {})
+
+      stub_request(:get, "https://api.github.com/repos/daigaku-ruby/Get_started_with_Ruby")
+        .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+        .to_return(status: 200, body: "{}", headers: {})
+
+      allow(subject).to receive(:download) { true }
+      allow(Daigaku::GithubClient).to receive(:updated?) { |attr| true }
+    end
+
+    after { cleanup_download(@zip_file_name) }
+
+    it "updates a course that is not from Github on each call" do
+      url = 'https://example.com/repo.zip'
+      expect(subject).to receive(:download).with(url, 'updated').once
+      subject.update('Course_A')
+    end
+
+    it "updates a course from Github if there are new contents" do
+      url = "https://github.com/user/repo/archive/master.zip"
+
+      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: {})
+
+      QuickStore.store.set('courses/course_a/url', url)
+
+      expect(subject).to receive(:download).with(url, 'updated').once
+      subject.update('Course_A')
+    end
+
+    it "does not update a course from Github if there are no new contents" do
+      allow(Daigaku::GithubClient).to receive(:updated?) { false }
+      url = "https://github.com/user/repo/archive/master.zip"
+
+      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: {})
+
+      QuickStore.store.set('courses/course_a/url', url)
+      QuickStore.store.set('courses/course_a/github', 'user/repo')
+
+      expect(subject).not_to receive(:download)
+      subject.update('Course_A')
+    end
   end
 
+  describe '#delete' do
+    before do
+      Daigaku.config.courses_path = local_courses_path
+      @course_path = course_dirs.first
+      prepare_courses unless Dir.exist?(@course_path)
+      allow(subject).to receive(:get).and_return('yes')
+    end
+
+    describe "confirmation" do
+      it "is nessecary to delete all courses" do
+        allow(subject).to receive(:options) { { all: true } }
+        expect(subject).to receive(:get_confirm)
+        subject.delete
+      end
+
+      it "is nessecary to delete a certain course" do
+        expect(subject).to receive(:get_confirm)
+        subject.delete(course_dir_names.first)
+      end
+    end
+
+    context "when confirmed:" do
+      it "deletes the given course" do
+        expect(Dir.exist?(@course_path)).to be_truthy
+        subject.delete(course_dir_names.first)
+        expect(Dir.exist?(@course_path)).to be_falsey
+      end
+
+      it "deletes all courses with option --all" do
+        allow(subject).to receive(:options) { { all: true } }
+        expect(Dir.exist?(@course_path)).to be_truthy
+        subject.delete
+
+        course_dirs.each do |dir|
+          expect(Dir.exist?(dir)).to be_falsey
+        end
+      end
+    end
+
+    context "when not confirmed:" do
+      before { allow(subject).to receive(:get).and_return('no') }
+
+      it "does not delete the given course" do
+        expect(Dir.exist?(@course_path)).to be_truthy
+        subject.delete(course_dir_names.first)
+        expect(Dir.exist?(@course_path)).to be_truthy
+      end
+
+      it "does not delete all courses" do
+        allow(subject).to receive(:options) { { all: true } }
+        expect(Dir.exist?(@course_path)).to be_truthy
+        subject.delete
+
+        course_dirs.each do |dir|
+          expect(Dir.exist?(dir)).to be_truthy
+        end
+      end
+    end
+
+    describe "status information" do
+      it "is printed when a certain course was deleted" do
+        expect(subject).to receive(:say_info)
+        subject.delete(course_dir_names.first)
+      end
+
+      it "is printed when all courses were deleted" do
+        allow(subject).to receive(:options) { { all: true } }
+        expect(subject).to receive(:say_info)
+        subject.delete
+      end
+    end
+
+    describe "QuickStore data" do
+      it "is deleted for a certain course" do
+        key = Daigaku::Storeable.key(course_dir_names.first, prefix: 'courses')
+        QuickStore.store.set(key, 'some value')
+        subject.delete(course_dir_names.first)
+        expect(QuickStore.store.get(key)).to be_nil
+      end
+
+      it "is deleted for all courses when option --all is set" do
+        allow(subject).to receive(:options) { { all: true } }
+
+        keys = course_dir_names.map do |course_name|
+          Daigaku::Storeable.key(course_name, prefix: 'courses')
+        end
+
+        course_dir_names.each_with_index do |course_name, index|
+          QuickStore.store.set(keys[index], course_name)
+        end
+
+        subject.delete
+
+        course_dir_names.each_with_index do |course_name, index|
+          expect(QuickStore.store.get(keys[index])).to be_nil
+        end
+
+      end
+    end
+  end
 end

data/spec/daigaku/terminal/output_spec.rb

@@ -22,7 +22,8 @@ describe Daigaku::Terminal::Output do
     :get,
     :say_info,
     :say_warning,
-    :get_command
+    :get_command,
+    :get_confirm
   ].each do |method|
     it "has the private method #{method}" do
       expect(subject.private_methods.include?(method)).to be_truthy
@@ -84,7 +85,6 @@ describe Daigaku::Terminal::Output do
   end
 
   describe "::get_command" do
-
     before do
       @correct_command = 'correct command'
       @description = 'description'
@@ -109,7 +109,7 @@ describe Daigaku::Terminal::Output do
     end
 
     context "with a wrong command typed  in:" do
-      it "writed a hint" do
+      it "writes 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)
@@ -120,4 +120,32 @@ describe Daigaku::Terminal::Output do
     end
   end
 
+  describe "::get_confirm" do
+    before do
+      @description = 'description'
+      allow($stdin).to receive(:gets).and_return('yes')
+    end
+
+    it "prints a warning with the given description" do
+      expect(subject).to receive(:say_warning).once.with(@description)
+      subject.send(:get_confirm, @description)
+    end
+
+    it "gets a command from the $stdin" do
+      expect($stdin).to receive(:gets)
+      subject.send(:get_confirm, @description)
+    end
+
+    it "takes a block to run when confirmed" do
+      allow(subject).to receive(:mocked_method).and_return('mocked method')
+      expect(subject).to receive(:mocked_method)
+      subject.send(:get_confirm, @description) { subject.mocked_method }
+    end
+
+    it "does not run the given block if not confirmed" do
+      allow(subject).to receive(:get).and_return('no')
+      expect(subject).not_to receive(:mocked_method)
+      subject.send(:get_confirm, @description) { subject.mocked_method }
+    end
+  end
 end

data/spec/daigaku/terminal_spec.rb

@@ -4,11 +4,21 @@ 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
+  describe "::text" do
+    it "loads a text from a file in the terminal/texts" do
       text = Daigaku::Terminal.text(:welcome)
       expect(text).to be_a String
     end
+
+    it "returns an empty string if the file does not exist" do
+      text = Daigaku::Terminal.text(:non_existent_text)
+      expect(text).to eq ''
+    end
+
+    it "returns an empty string if the file has no content" do
+      allow(File).to receive(:read) { '' }
+      expect(Daigaku::Terminal.text(:congratulations)).to eq ''
+    end
   end
 
 end

data/spec/daigaku/test_result_spec.rb

@@ -9,6 +9,7 @@ describe Daigaku::TestResult do
   it { is_expected.to respond_to :examples }
   it { is_expected.to respond_to :passed? }
   it { is_expected.to respond_to :summary }
+  it { is_expected.to respond_to :summary_lines }
 
   context "with passed input:" do
 
@@ -19,7 +20,7 @@ describe Daigaku::TestResult do
     end
 
     it "has a default summary" do
-      expect(subject.summary).to eq test_passed_summary
+      expect(subject.summary).to include test_passed_summary
     end
   end
 
@@ -62,7 +63,7 @@ describe Daigaku::TestResult do
 
           expect(example.description).to eq description
           expect(example.status).to eq status
-          expect(example.message).to eq message
+          expect(example.message).to include message
         end
       end
     end
@@ -78,4 +79,13 @@ describe Daigaku::TestResult do
     end
   end
 
+  describe "#summary_lines" do
+    it "returns the summary split into lines" do
+      lines = ['This', 'is', 'summary', 'for', 'a', 'test']
+      allow(subject).to receive(:summary) { lines.join("\n") }
+
+      expect(subject.summary_lines).to eq lines
+    end
+  end
+
 end