belajar 0.1.1

data/spec/belajar/congratulator_spec.rb

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

data/spec/belajar/course_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe Belajar::Course do
+
+  it { is_expected.to respond_to :title }
+  it { is_expected.to respond_to :chapters }
+  it { is_expected.to respond_to :path }
+  it { is_expected.to respond_to :author }
+  it { is_expected.to respond_to :link }
+
+  it { is_expected.to respond_to :mastered? }
+  it { is_expected.to respond_to :started? }
+
+  let(:course_path) { course_dirs.first }
+
+  before { suppress_print_out }
+
+  before(:all) do
+    prepare_solutions
+    Belajar.config.solutions_path = solutions_basepath
+  end
+
+  subject { Belajar::Course.new(course_path) }
+
+  it "responds to ::unzip" do
+    expect(Belajar::Course).to respond_to :unzip
+  end
+
+  it "has the prescribed title" do
+    expect(subject.title).to eq course_titles.first
+  end
+
+  it "has the prescribed path" do
+    expect(subject.path).to eq course_path
+  end
+
+  it "is not started by default" do
+    expect(subject.started?).to be_falsey
+  end
+
+  it "is not mastered by default" do
+    expect(subject.mastered?).to be_falsey
+  end
+
+  describe "#chapters" do
+    it "loads the prescribed number of chapters" do
+      expect(subject.chapters.count).to eq available_chapters(course_path).count
+    end
+
+    it "lazy-loads the chapters" do
+      expect(subject.instance_variable_get(:@chapters)).to be_nil
+      subject.chapters
+      expect(subject.instance_variable_get(:@chapters)).not_to be_nil
+    end
+  end
+
+  describe "#started?" do
+    it "returns true if at least one chapter has been started" do
+      allow(subject.chapters.first).to receive(:started?) { true }
+      expect(subject.started?).to be true
+    end
+
+    it "returns false if no chapter has been started" do
+      allow_any_instance_of(Belajar::Chapter).to receive(:started?) { false }
+      expect(subject.started?).to be false
+    end
+  end
+
+  describe "#mastered?" do
+    it "returns true if all chapters have been mastered" do
+      allow_any_instance_of(Belajar::Chapter).to receive(:mastered?) { true }
+      expect(subject.mastered?).to be true
+    end
+
+    it "returns false unless all chapters have been mastered" do
+      allow_any_instance_of(Belajar::Chapter).to receive(:mastered?) { false }
+      allow(subject.chapters.first).to receive(:mastered?) { true }
+      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 = Belajar::Course.new(course_path)
+      expect(course.author).to eq author
+    end
+  end
+
+  describe "::unzip" do
+    before do
+      Belajar.config.courses_path = local_courses_path
+      @zip_file_name = "unzip/repo.zip"
+      @zip_file_path = File.join(courses_basepath, @zip_file_name)
+      @file_content = prepare_download(@zip_file_name)
+    end
+
+    after do
+      cleanup_download(@zip_file_name)
+      dir = File.dirname(@zip_file_path)
+      FileUtils.rm_r(dir) if Dir.exist?(dir)
+    end
+
+    def expect_course_dirs_exists_to_be(boolean)
+      unit_dirs(course_dir_names.first).each do |chapter_dirs|
+        chapter_dirs.each do |dir|
+          path = [dir.split('/')[0..-4], 'unzip', dir.split('/')[-3..-1]].join('/')
+          expect(Dir.exist?(path)).to be boolean
+        end
+      end
+    end
+
+    it "unzips a course zip file" do
+      expect_course_dirs_exists_to_be false
+      Belajar::Course.unzip(@zip_file_path)
+      expect_course_dirs_exists_to_be true
+    end
+
+    it "returns the unzipped course" do
+      dir = course_dirs.first
+      path = File.join(File.dirname(dir), 'unzip', File.basename(dir))
+      course = Belajar::Course.new(path)
+
+      expect(Belajar::Course.unzip(@zip_file_path).to_json).to eql course.to_json
+    end
+
+    it "removes the zip file" do
+      expect(File.exist?(@zip_file_path)).to be true
+      Belajar::Course.unzip(@zip_file_path)
+      expect(File.exist?(@zip_file_path)).to be false
+    end
+
+    context "with the same course already available:" do
+      before do
+        dir = course_dirs.first
+        @path = File.join(File.dirname(dir), 'unzip', File.basename(dir))
+        @old_chapter_dir = File.join(@path, 'Old_chapter')
+
+        FileUtils.mkdir_p(@old_chapter_dir)
+      end
+
+      it "overwrites all chapters" do
+        expect(Dir.exist?(@old_chapter_dir)).to be true
+        Belajar::Course.unzip(@zip_file_path)
+        expect(Dir.exist?(@old_chapter_dir)).to be false
+      end
+
+      context "if an errior occurs" do
+        before do
+          allow_any_instance_of(Zip::File)
+            .to receive(:extract) { raise Exception.new }
+        end
+
+        it "restores an old state if an error occurs" do
+          Belajar::Course.unzip(@zip_file_path)
+          expect(Dir.exist?(@old_chapter_dir)).to be true
+          expect(Dir.exist?("#{@path}_old")).to be false
+        end
+
+        it "keeps the zip file if an error occurs" do
+          expect(File.exist?(@zip_file_path)).to be true
+          Belajar::Course.unzip(@zip_file_path)
+          expect(File.exist?(@zip_file_path)).to be true
+        end
+      end
+    end
+
+    context "with the github_repo option:" do
+      before { @github_course_dir = prepare_github_course }
+      after { FileUtils.rm_r(@github_course_dir) }
+
+      it "removes the '-master' from the root directory" do
+        zip_file_name = "unzip/repo-master.zip"
+        zip_file_path = File.join(courses_basepath, zip_file_name)
+        prepare_github_download(zip_file_name)
+
+        expect(File.exist?(zip_file_path)).to be true
+        Belajar::Course.unzip(zip_file_path, github_repo: true)
+
+        unit_dirs("#{course_dir_names.first}-master").each do |chapter_dirs|
+          chapter_dirs.each do |dir|
+            path = [dir.split('/')[0..-4], 'unzip', dir.split('/')[-3..-1]].join('/')
+            expect(Dir.exist?(path)).to be false
+          end
+        end
+
+        expect_course_dirs_exists_to_be true
+      end
+    end
+  end
+end

data/spec/belajar/generator_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Belajar::Generator do
+
+  it { is_expected.to respond_to :scaffold }
+  it { is_expected.to respond_to :prepare }
+
+  subject { Belajar::Generator.new }
+
+  before do
+    Belajar.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
+        Belajar.configure do |config|
+          config.solutions_path = solutions_basepath
+          config.courses_path = local_courses_path
+        end
+
+        subject.prepare
+      end
+
+      it "generates a '<basepath>/.belajar/belajar.db.yml' file" do
+        expect(File.exist?(local_storage_file)).to be_truthy
+      end
+
+      it "generates a '<basepath>/.belajar/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(QuickStore.store.courses_path).to eq local_courses_path
+        expect(QuickStore.store.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(Belajar.config.courses_path)
+        @solutions_path =  File.join(base_path, 'solutions')
+
+        Belajar.config.instance_variable_set(:@solutions_path, nil)
+        Belajar.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>/.belajar/belajar.db.yml' file" do
+        expect(File.exist?(local_storage_file)).to be_truthy
+      end
+
+      it "generates a '<basepath>/.belajar/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(QuickStore.store.courses_path).to eq local_courses_path
+        expect(QuickStore.store.solutions_path).to eq @solutions_path
+      end
+    end
+  end
+
+end

data/spec/belajar/github_client_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Belajar::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(Belajar::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 = Belajar::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(Belajar::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(Belajar::GithubClient.updated?('a/b')).to be_falsey
+    end
+
+    it "returns false if param is nil" do
+      expect(Belajar::GithubClient.updated?(nil)).to be_falsey
+    end
+  end
+end

data/spec/belajar/loading/chapters_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Belajar::Loading::Chapters do
+
+  let(:subjects) { Belajar::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/belajar/loading/courses_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Belajar::Loading::Courses do
+
+  let(:subjects) { Belajar::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/belajar/loading/units_spec.rb

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Belajar::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
+    unit_dirs(course_name)[0].first
+  end
+
+  subject { Belajar::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
+
+  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