belajar 0.1.1

data/spec/belajar/solution_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Belajar::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
+    Belajar.config.solutions_path = solutions_basepath
+  end
+
+  let(:solution_path) { all_solution_file_paths.first }
+  let(:unit_path) { all_unit_dirs.first }
+
+  subject { Belajar::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 store on creation" do
+    Belajar::Solution.new(unit_path).verify!
+    solution = Belajar::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
+        expect(subject.verify!).to be_a Belajar::TestResult
+      end
+
+      it "sets @verified true if Test passed" do
+        QuickStore.store.set(subject.store_key, false)
+        solution = Belajar::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 store to verified if passed" do
+        subject.verify!
+        mastered = QuickStore.store.get(subject.store_key)
+
+        expect(mastered).to be_truthy
+      end
+
+      it "sets the solution's state in the store to unverified unless passed" do
+        subject.instance_variable_set(:@code, 'puts "I ❤ Belajar!"')
+        subject.verify!
+        mastered = QuickStore.store.get(subject.store_key)
+
+        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/belajar/storeable_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Belajar::Storeable do
+
+  it "responds to ::key" do
+    expect(Belajar::Storeable).to respond_to :key
+  end
+
+  describe '::key' do
+    it "creates a store key from the given string" do
+      key = Belajar::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 = Belajar::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 = Belajar::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 = Belajar::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 = Belajar::Storeable.key('1-_Raw content-Title', suffixes: ['meta', '1-author'] )
+      expect(key).to eq 'raw_content_title/meta/author'
+    end
+  end
+end

data/spec/belajar/task_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Belajar::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 { Belajar::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/belajar/terminal/cli_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Belajar::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 belajar terminal app if there are courses" do
+      allow(Belajar::Loading::Courses).to receive(:load) { [1] }
+      allow(Belajar).to receive(:start) { true }
+      expect(Belajar).to receive(:start)
+
+      subject.learn
+    end
+
+    it "does not start the belajar terminal app if there are no courses" do
+      suppress_print_out
+      allow(Belajar::Loading::Courses).to receive(:load) { [] }
+      allow(Belajar).to receive(:start) { true }
+      expect(Belajar).not_to receive(:start)
+
+      subject.learn
+    end
+  end
+
+  describe "#welcome" do
+    it "runs the welcome routine" do
+      allow(Belajar::Terminal::Welcome).to receive(:run) { true }
+      expect(Belajar::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(Belajar::Generator).to receive(:scaffold) { true }
+      expect_any_instance_of(Belajar::Generator).to receive(:scaffold).once
+
+      subject.scaffold
+    end
+  end
+end

data/spec/belajar/terminal/courses_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+describe Belajar::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
+      Belajar.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/wong-bejo/Get_started_with_Ruby")
+        .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+        .to_return(status: 200, body: "{}", 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 "uses Courses.unzip to unzip the course" do
+      expect(Belajar::Course).to receive(:unzip).once
+      subject.download(@url)
+    end
+
+    it "creates a new courses folder in the belajar courses directory" do
+      target_path = File.join(Belajar.config.courses_path, File.basename(course_dirs.first))
+      dirs = Dir[File.join(Belajar.config.courses_path, '**')]
+      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
+
+    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
+      Belajar.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/wong-bejo/Get_started_with_Ruby")
+        .with(headers: { 'Accept' => '*/*', 'User-Agent' => 'Ruby' })
+        .to_return(status: 200, body: "{}", headers: {})
+
+      allow(subject).to receive(:download) { true }
+      allow(Belajar::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(Belajar::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
+
+    it "updates all courses if --all option is given" do
+      file_content = prepare_download(@zip_file_name, multiple_courses: true)
+
+      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: {})
+
+      allow(subject).to receive(:options) { { all: true } }
+      allow(subject).to receive(:download).exactly(course_dirs.count).times
+
+      subject.update
+    end
+  end
+
+  describe '#delete' do
+    before do
+      Belajar.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 = Belajar::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|
+          Belajar::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