bebox 0.0.1

data/spec/node_role_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require_relative '../spec/factories/role.rb'
+require_relative '../spec/factories/node.rb'
+require_relative '../spec/factories/provision.rb'
+
+describe 'Test 10: Associate node and role' do
+
+  let(:role) { build(:role) }
+  let(:nodes) { [build(:node)] }
+
+  context 'set role' do
+    it 'should add a role to a node' do
+      node = nodes.first
+      Bebox::Provision.associate_node_role(node.project_root, node.environment, node.hostname, role.name)
+      expected_content = File.read('spec/fixtures/puppet/steps/step-2/manifests/site_with_node_role_association.pp.test').strip
+      output_file = File.read("#{node.project_root}/puppet/steps/2-services/manifests/site.pp").strip
+      expect(output_file).to eq(expected_content)
+    end
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require_relative '../spec/factories/node.rb'
+
+describe 'Test 04: Bebox::Node' do
+
+  describe 'Nodes management' do
+
+    subject { build(:node) }
+
+    context 'node creation' do
+      it 'should create hiera data template' do
+        subject.create_hiera_template
+        Bebox::PROVISION_STEPS.each do |step|
+          expect(File.exist?("#{subject.project_root}/puppet/steps/#{Bebox::Provision.step_name(step)}/hiera/data/#{subject.hostname}.yaml")).to eq(true)
+        end
+      end
+
+      it 'should create node in manifests file' do
+        subject.create_manifests_node
+        Bebox::PROVISION_STEPS.each do |step|
+          content = File.read("spec/fixtures/puppet/steps/#{step}/manifests/site_with_node.pp.test").gsub(/\s+/, ' ').strip
+          output = File.read("#{subject.project_root}/puppet/steps/#{Bebox::Provision.step_name(step)}/manifests/site.pp").gsub(/\s+/, ' ').strip
+          expect(output).to eq(content)
+        end
+      end
+
+      it 'should create checkpoint' do
+        subject.create_node_checkpoint
+        expect(File.exist?("#{subject.project_root}/.checkpoints/environments/#{subject.environment}/nodes/#{subject.hostname}.yml")).to be (true)
+        node_content = File.read("#{subject.project_root}/.checkpoints/environments/#{subject.environment}/nodes/#{subject.hostname}.yml").gsub(/\s+/, ' ').strip
+        ouput_template = Tilt::ERBTemplate.new('spec/fixtures/node/node_0.test.erb')
+        node_output_content = ouput_template.render(nil, node: subject).gsub(/\s+/, ' ').strip
+        expect(node_content).to eq(node_output_content)
+      end
+
+      it 'should list the current nodes' do
+        current_nodes = [subject.hostname]
+        nodes = Bebox::Node.list(subject.project_root, subject.environment, 'nodes')
+        expect(nodes).to include(*current_nodes)
+      end
+    end
+
+    context 'node deletion' do
+      it 'should remove checkpoint' do
+        subject.remove_checkpoints
+        expect(File.exist?("#{subject.project_root}/.checkpoints/environments/#{subject.environment}/nodes/#{subject.hostname}.yml")).to be (false)
+      end
+
+      it 'should not list any nodes' do
+        nodes = Bebox::Node.list(subject.project_root, subject.environment, 'nodes')
+        expect(nodes.count).to eq(0)
+      end
+
+      it 'should remove hiera data' do
+        subject.remove_hiera_template
+        Bebox::PROVISION_STEPS.each do |step|
+          expect(File.exist?("#{subject.project_root}/puppet/steps/#{Bebox::Provision.step_name(step)}/hiera/data/#{subject.hostname}.yaml")).to be (false)
+        end
+      end
+
+      it 'should remove node from manifests' do
+        subject.remove_manifests_node
+        Bebox::PROVISION_STEPS.each do |step|
+          content = File.read("spec/fixtures/puppet/steps/#{step}/manifests/site.pp.test").gsub(/\s+/, ' ').strip
+          output = File.read("#{subject.project_root}/puppet/steps/#{Bebox::Provision.step_name(step)}/manifests/site.pp").gsub(/\s+/, ' ').strip
+          expect(output).to eq(content)
+        end
+      end
+    end
+  end
+end

data/spec/node_wizard_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+require_relative '../spec/factories/node.rb'
+
+describe 'Test 03: Manage nodes with the wizard' do
+
+  subject { Bebox::NodeWizard.new }
+
+  let(:project_root) { "#{Dir.pwd}/tmp/bebox-pname" }
+  let(:environment) { "vagrant" }
+  let(:node_hostname) { "node_0.server1.test" }
+  let(:node_ip) { YAML.load_file('spec/support/config_specs.yaml')['test_ip'] }
+
+  it 'should check node existence' do
+    output = subject.node_exists?(project_root, environment, node_hostname)
+    expect(output).to eq(false)
+  end
+
+  it 'the ip should be free' do
+    expect(subject.free_ip?(node_ip)).to eq(true)
+  end
+end

data/spec/ordered_phases_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'project_wizard_spec'
+require 'project_spec'
+require 'environment_spec'
+require 'node_wizard_spec'
+require 'node_spec'
+require 'pre_prepare_spec'
+require 'node0.server1.test/prepare_phase_spec'
+require 'role_spec'
+require 'profile_spec'
+require 'role_profiles_spec'
+require 'node_role_spec'
+require 'pre_provision_steps_spec'
+require 'node0.server1.test/provision_step_0_spec'
+require 'node0.server1.test/provision_step_1_spec'
+require 'node0.server1.test/provision_step_2_spec'
+require 'node0.server1.test/provision_step_3_spec'
+
+
+describe 'Test 99: ordered specs' do
+
+  RSpec.configure do |config|
+    puts 'Configure spec order'
+    config.order_groups_and_examples do |list|
+      list.sort_by { |item| item.description if item.class != RSpec::Core::Example }
+    end
+  end
+
+  context '99: project destroy' do
+
+    let(:project) { build(:project) }
+    let(:node) { build(:node) }
+
+    it 'should clean spec files' do
+      # Test if the vagrant was halt
+      Bebox::Node.halt_vagrant_nodes(node.project_root)
+      expect(node.vagrant_box_running?).to be(false)
+      # Test if the vagrant box was destroyed
+      node.remove_vagrant_box
+      expect(node.vagrant_box_exist?).to be(false)
+      # Test if the project directory was destroyed
+      project.destroy
+      expect(Dir.exist?("#{project.path}")).to be(false)
+      # Test that the local hosts file was restored
+      puts "\nPlease provide your account password, if ask you, to restore the local hosts file.".yellow
+      hosts_backup_content = File.read("#{node.local_hosts_path}/hosts_before_#{project.name}").gsub(/\s+/, ' ').strip
+      node.restore_local_hosts(project.name)
+      hosts_content = File.read("#{node.local_hosts_path}/hosts").gsub(/\s+/, ' ').strip
+      expect(hosts_content).to eq(hosts_backup_content)
+      expect(File.exist?("#{node.local_hosts_path}/hosts_before_#{project.name}")).to be(false)
+    end
+  end
+
+  specify("End of tests") {}
+end

data/spec/pre_prepare_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'tilt'
+require 'colorize'
+require_relative '../spec/factories/node.rb'
+
+describe 'Test 05: Bebox::Node' do
+
+  describe 'Pre-prepare nodes' do
+
+    let(:nodes) { 1.times.map{|index| build(:node, :created, hostname: "node#{index}.server1.test")} }
+    let(:project_root) { "#{Dir.pwd}/tmp/bebox-pname" }
+    let(:environment) { 'vagrant' }
+    let(:project_name) {'bebox-pname'}
+    let(:vagrant_box_base) {"#{Dir.pwd}/ubuntu-server-12042-x64-vbox4210-nocm.box"}
+
+    context 'pre vagrant prepare' do
+      it 'should generate the Vagrantfile' do
+        Bebox::Node.generate_vagrantfile(project_root, nodes)
+        vagrantfile_content = File.read("#{project_root}/Vagrantfile").gsub(/\s+/, ' ').strip
+        ouput_template = Tilt::ERBTemplate.new('spec/fixtures/node/Vagrantfile.test.erb')
+        vagrantfile_output_content = ouput_template.render(nil, ip_address: nodes.first.ip).gsub(/\s+/, ' ').strip
+        expect(vagrantfile_content).to eq(vagrantfile_output_content)
+      end
+      it 'should regenerate the vagrant deploy file' do
+        Bebox::Node.regenerate_deploy_file(project_root, environment, nodes)
+        vagrant_deploy_content = File.read("#{project_root}/config/deploy/vagrant.rb").gsub(/\s+/, ' ').strip
+        vagrant_deploy_output_content = File.read("spec/fixtures/node/vagrant_deploy.test").gsub(/\s+/, ' ').strip
+        expect(vagrant_deploy_content).to eq(vagrant_deploy_output_content)
+      end
+    end
+
+    context 'vagrant prepare' do
+      describe 'Configure the hosts file' do
+        it 'should create a hosts backup file' do
+          node = nodes.first
+          puts "\nPlease provide your account password, if ask you, to configure the local hosts file.".yellow
+          `sudo rm -rf #{node.local_hosts_path}/hosts_before_#{project_name}`
+          original_hosts_content = File.read("#{node.local_hosts_path}/hosts").gsub(/\s+/, ' ').strip
+          nodes.each{|node| node.backup_local_hosts(project_name)}
+          hosts_backup_file = "#{node.local_hosts_path}/hosts_before_#{project_name}"
+          expect(File).to exist(hosts_backup_file)
+          hosts_backup_content = File.read(hosts_backup_file).gsub(/\s+/, ' ').strip
+          expect(original_hosts_content).to eq(hosts_backup_content)
+        end
+
+        it 'should add the hosts config to hosts file' do
+          nodes.each{|node| node.add_to_local_hosts}
+          node = nodes.first
+          hosts_content = File.read("#{node.local_hosts_path}/hosts").gsub(/\s+/, ' ').strip
+          expect(hosts_content).to include(*nodes.map{|node| "#{node.ip} #{node.hostname}"})
+        end
+      end
+
+      describe 'vagrant setup' do
+        it 'should add the node to vagrant' do
+          vagrant_box_names_expected = nodes.map{|node| "#{project_name}-#{node.hostname}"}
+          nodes.each{|node| node.add_vagrant_node(project_name, vagrant_box_base)}
+          node = nodes.first
+          expect(node.installed_vagrant_box_names).to include(*vagrant_box_names_expected)
+        end
+
+        it 'should up the vagrant boxes' do
+          Bebox::Node.up_vagrant_nodes(project_root)
+          nodes.each{|node| expect(node.vagrant_box_running?).to eq(true)}
+        end
+
+        it 'should connect to vagrant box through ssh' do
+          connection_successful = true
+          nodes.each do |node|
+            `ssh -q -oStrictHostKeyChecking=no -i ~/.vagrant.d/insecure_private_key -l vagrant #{node.ip} exit`
+            connection_successful &= ($?.exitstatus == 0)
+          end
+          expect(connection_successful).to eq(true)
+        end
+      end
+    end
+  end
+end

data/spec/pre_provision_steps_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require_relative '../spec/factories/role.rb'
+require_relative '../spec/factories/profile.rb'
+require_relative '../spec/factories/provision.rb'
+
+describe 'Test 11: Pre provision apply step' do
+
+  let(:provision) { build(:provision, step: 'step-2') }
+  let(:role) { build(:role) }
+  let(:profile) { build(:profile) }
+  let(:profiles) { [profile.relative_path] }
+
+  before :all do
+    role.create
+    profile.create
+    Bebox::Role.add_profile(role.project_root, role.name, profile.relative_path)
+    `cp spec/fixtures/puppet/profiles/#{profile.relative_path}/Puppetfile_with_modules.test #{profile.absolute_path}/Puppetfile`
+  end
+
+  it 'should generate a Puppetfile' do
+    Bebox::Provision.generate_puppetfile(provision.project_root, provision.step, [profile.relative_path])
+    output_file = File.read("#{provision.project_root}/puppet/steps/#{Bebox::Provision.step_name(provision.step)}/Puppetfile").gsub(/\s+/, ' ').strip
+    expected_content = File.read("spec/fixtures/puppet/steps/#{provision.step}/Puppetfile.test").gsub(/\s+/, ' ').strip
+    expect(output_file).to eq(expected_content)
+  end
+
+  it 'should generate the roles and profiles modules' do
+    Bebox::Provision.generate_roles_and_profiles(provision.project_root, provision.step, role.name, [profile.relative_path])
+    # Expect the role is created
+    output_file = File.read("#{provision.project_root}/puppet/steps/#{Bebox::Provision.step_name(provision.step)}/modules/roles/manifests/#{role.name}.pp").gsub(/\s+/, ' ').strip
+    expected_content = File.read("spec/fixtures/puppet/steps/#{provision.step}/modules/roles/manifests/#{role.name}.pp.test").gsub(/\s+/, ' ').strip
+    expect(output_file).to eq(expected_content)
+    # Expect the profiles are created
+    profiles.each do |profile_name|
+      output_file = File.read("#{provision.project_root}/puppet/steps/#{Bebox::Provision.step_name(provision.step)}/modules/profiles/manifests/#{profile_name}.pp").gsub(/\s+/, ' ').strip
+      expected_content = File.read("spec/fixtures/puppet/steps/#{provision.step}/modules/profiles/manifests/#{profile_name}.pp.test").gsub(/\s+/, ' ').strip
+      expect(output_file).to eq(expected_content)
+    end
+  end
+end

data/spec/profile_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require_relative '../spec/factories/profile.rb'
+
+describe 'Test 08: Bebox::Profile' do
+
+  describe 'Manage profiles' do
+
+    subject { build(:profile) }
+
+    before :all do
+      subject.create
+    end
+
+    context '00: profile creation' do
+
+      it 'should validate the profile name' do
+        # Test not valid reserved words
+        Bebox::RESERVED_WORDS.each{|reserved_word| expect(Bebox::Profile.valid_name?(reserved_word)).to be (false)}
+        # Test not valid start by undescore
+        expect(Bebox::Profile.valid_name?('_profile_0')).to be (false)
+        # Test not valid contain Upper letter
+        expect(Bebox::Profile.valid_name?('Profile_0')).to be (false)
+        # Test not valid contain dash character
+        expect(Bebox::Profile.valid_name?('profile-0')).to be (false)
+        # Test valid name not contains reserved words, start with letter, contains only downcase letters, numbers and undescores
+        expect(Bebox::Profile.valid_name?(subject.name)).to be (true)
+      end
+
+      it 'should clean the profile path' do
+        # Profile path with slash
+        expect(Bebox::Profile.cleanpath('/')).to eq ('')
+        # Profile path with multiple slashes
+        expect(Bebox::Profile.cleanpath('///basic//test///')).to eq ('basic/test')
+        # Subject path is correct so would be the same
+        expect(Bebox::Profile.cleanpath(subject.path)).to eq (subject.path)
+      end
+
+      it 'should create profile directories' do
+        expect(Dir.exist?("#{subject.absolute_path}/manifests")).to be (true)
+      end
+
+      it 'should generate the manifests file' do
+        output_file = File.read("#{subject.absolute_path}/manifests/init.pp").strip
+        expected_content = File.read("spec/fixtures/puppet/profiles/#{subject.relative_path}/manifests/init.pp.test").strip
+        expect(output_file).to eq(expected_content)
+      end
+
+      it 'should generate the Puppetfile' do
+        output_file = File.read("#{subject.absolute_path}/Puppetfile").strip
+        expected_content = File.read("spec/fixtures/puppet/profiles/#{subject.relative_path}/Puppetfile.test").strip
+        expect(output_file).to eq(expected_content)
+      end
+    end
+
+    context '01: profile list' do
+      it 'should list profiles' do
+        current_profiles = [subject.relative_path]
+        profiles = Bebox::Profile.list(subject.project_root)
+        expect(profiles).to include(*current_profiles)
+      end
+    end
+
+    context '02: profile deletion' do
+      it 'should delete profile directory' do
+        subject.remove
+        expect(Dir.exist?("#{subject.absolute_path}")).to be (false)
+      end
+    end
+  end
+end

data/spec/project_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+require_relative '../spec/factories/project.rb'
+
+describe 'Test 01: Bebox::Project' do
+
+  describe 'Project creation' do
+
+    subject { build(:project) }
+
+    it 'should create the project directory' do
+      subject.create_project_directory
+      expect(Dir.exist?(subject.path)).to be true
+    end
+
+    context '00: Project config files creation' do
+      it 'should create the templates directories' do
+        directories_expected = ['templates', 'roles', 'profiles']
+        subject.create_templates_directories
+        directories = []
+        directories << Dir["#{subject.path}/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/*/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/*/*/*/"].map { |f| File.basename(f) }
+        expect(directories.flatten).to include(*directories_expected)
+      end
+
+      it 'should create config deploy directories' do
+        directories_expected = ['config', 'deploy', 'keys', 'environments']
+        subject.create_config_deploy_directories
+        directories = []
+        directories << Dir["#{subject.path}/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/*/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/*/*/*/"].map { |f| File.basename(f) }
+        expect(directories.flatten).to include(*directories_expected)
+      end
+
+      it 'should generate a .bebox file' do
+        subject.generate_dot_bebox_file
+        dotbebox_content = File.read("#{subject.path}/.bebox").gsub(/\s+/, ' ').strip
+        ouput_template = Tilt::ERBTemplate.new('spec/fixtures/dot_bebox.test.erb')
+        dotbebox_expected_content = ouput_template.render(nil, created_at: subject.created_at).gsub(/\s+/, ' ').strip
+        expect(dotbebox_content).to eq(dotbebox_expected_content)
+      end
+
+      it 'should generate a .gitignore file' do
+        subject.generate_gitignore_file
+        expected_content = File.read("#{subject.path}/.gitignore")
+        output_file = File.read('spec/fixtures/dot_gitignore.test')
+        expect(output_file).to eq(expected_content)
+      end
+
+      it 'should generate a .ruby-version file' do
+        subject.generate_ruby_version
+        version = File.read("#{subject.path}/.ruby-version").strip
+        expect(version).to eq(RUBY_VERSION)
+      end
+
+      it 'should create a Capfile' do
+        subject.create_capfile
+        expected_content = File.read("#{subject.path}/Capfile")
+        output_file = File.read('spec/fixtures/Capfile.test')
+        expect(output_file).to eq(expected_content)
+      end
+
+      it 'should generate deploy file' do
+        subject.generate_deploy_file
+        config_deploy_content = File.read("#{subject.path}/config/deploy.rb").gsub(/\s+/, ' ').strip
+        config_deploy_output_content = File.read("spec/fixtures/config/deploy.test").gsub(/\s+/, ' ').strip
+        expect(config_deploy_content).to eq(config_deploy_output_content)
+      end
+
+      it 'should create Gemfile' do
+        subject.create_gemfile
+        content = File.read("#{subject.path}/Gemfile").gsub(/\s+/, ' ').strip
+        output = File.read("spec/fixtures/Gemfile.test").gsub(/\s+/, ' ').strip
+        expect(output).to eq(content)
+      end
+    end
+
+    context '01: Create puppet base' do
+      it 'should generate SO dependencies files' do
+        subject.generate_so_dependencies_files
+        content = File.read("#{subject.path}/puppet/prepare/dependencies/ubuntu/packages")
+        output = File.read("spec/fixtures/puppet/ubuntu_dependencies.test")
+        expect(output).to eq(content)
+      end
+
+      it 'should copy puppet install files' do
+        subject.copy_puppet_install_files
+        expect(Dir.exist?("#{subject.path}/puppet/lib/deb/puppet_3.6.0")).to be (true)
+        expect(Dir["#{subject.path}/puppet/lib/deb/puppet_3.6.0/*"].count).to eq(18)
+      end
+
+      it 'should generate steps directories' do
+        expected_directories = ['prepare', 'profiles', 'roles', 'steps',
+          '0-fundamental', '1-users', '2-services', '3-security',
+          'hiera', 'manifests', 'modules', 'data']
+        subject.generate_steps_directories
+        directories = []
+        directories << Dir["#{subject.path}/puppet/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/puppet/*/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/puppet/*/*/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/puppet/*/*/*/*/"].map { |f| File.basename(f) }
+        expect(directories.flatten).to include(*expected_directories)
+      end
+
+      it 'should copy the default roles and profiles' do
+        expected_roles_directories = ['fundamental', 'security', 'users']
+        expected_profiles_directories = ['profiles', 'base', 'fundamental', 'ruby', 'manifests', 'sudo', 'users', 'security', 'fail2ban', 'iptables', 'ssh', 'sysctl']
+        subject.copy_default_roles_profiles
+        directories = Dir["#{subject.path}/puppet/roles/*/"].map { |f| File.basename(f) }.uniq
+        expect(directories).to include(*expected_roles_directories)
+        directories = Dir["#{subject.path}/puppet/profiles/**/"].map { |f| File.basename(f) }.uniq
+        expect(directories).to include(*expected_profiles_directories)
+      end
+
+      context '02: generate steps templates' do
+        before :all do
+          subject.generate_steps_templates
+        end
+        it 'should generate manifests template' do
+          Bebox::PROVISION_STEPS.each do |step|
+            content = File.read("spec/fixtures/puppet/steps/#{step}/manifests/site.pp.test")
+            output = File.read("#{subject.path}/puppet/steps/#{Bebox::Provision.step_name(step)}/manifests/site.pp")
+            expect(output).to eq(content)
+          end
+        end
+        it 'should generate hiera template' do
+          Bebox::PROVISION_STEPS.each do |step|
+            content = File.read("spec/fixtures/puppet/steps/#{step}/hiera/hiera.yaml.test")
+            output = File.read("#{subject.path}/puppet/steps/#{Bebox::Provision.step_name(step)}/hiera/hiera.yaml")
+            expect(output).to eq(content)
+          end
+        end
+        it 'should generate hiera data common' do
+          Bebox::PROVISION_STEPS.each do |step|
+            content = File.read("spec/fixtures/puppet/steps/#{step}/hiera/data/common.yaml.test")
+            output = File.read("#{subject.path}/puppet/steps/#{Bebox::Provision.step_name(step)}/hiera/data/common.yaml")
+            expect(output).to eq(content)
+          end
+        end
+      end
+    end
+
+    context '03: checkpoints' do
+      it 'should create checkpoints directories' do
+        expected_directories = ['.checkpoints', 'environments']
+        subject.create_checkpoints
+        directories = []
+        directories << Dir["#{subject.path}/.checkpoints/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/.checkpoints/*/"].map { |f| File.basename(f) }
+        expect(directories.flatten).to include(*expected_directories)
+      end
+    end
+
+    context '04: bundle project' do
+      it 'should install dependencies' do
+        subject.bundle_project
+        expect(File).to exist("#{subject.path}/Gemfile.lock")
+      end
+    end
+
+    context '05: create default environments' do
+
+      before(:all) do
+        subject.create_default_environments
+      end
+
+      it 'should generate deploy files' do
+        subject.environments.each do |environment|
+          config_deploy_vagrant_content = File.read("#{subject.path}/config/deploy/#{environment.name}.rb").gsub(/\s+/, ' ').strip
+          config_deploy_vagrant_output_content = File.read("spec/fixtures/config/deploy/#{environment.name}.test").gsub(/\s+/, ' ').strip
+          expect(config_deploy_vagrant_content).to eq(config_deploy_vagrant_output_content)
+        end
+      end
+
+      it 'should create checkpoints' do
+        expected_directories = ['vagrant', 'staging', 'production', 'nodes', 'prepared_nodes',
+          'steps', 'step-0', 'step-1', 'step-2', 'step-3']
+        directories = []
+        directories << Dir["#{subject.path}/.checkpoints/environments/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/.checkpoints/environments/*/*/"].map { |f| File.basename(f) }
+        directories << Dir["#{subject.path}/.checkpoints/environments/*/*/*/"].map { |f| File.basename(f) }
+        expect(directories.flatten).to include(*expected_directories)
+      end
+
+      it 'should create capistrano base' do
+        subject.environments.each do |environment|
+          expect(Dir.exist?("#{subject.path}/config/keys/environments/#{environment.name}")).to be (true)
+        end
+        expect(File.exist?("#{subject.path}/config/keys/environments/vagrant/id_rsa")).to be (true)
+        expect(File.exist?("#{subject.path}/config/keys/environments/vagrant/id_rsa.pub")).to be (true)
+      end
+    end
+  end
+end

data/spec/project_wizard_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+# require 'vcr'
+
+require_relative '../spec/factories/project.rb'
+
+describe 'Test 00: Create a new project with the wizard' do
+
+  describe 'Project data provision' do
+
+    subject { Bebox::ProjectWizard.new }
+
+    let(:project_name) { 'bebox-pname' }
+    let(:parent_path) { "#{Dir.pwd}/tmp" }
+    let(:http_box_uri) {'http://puppet-vagrant-boxes.puppetlabs.com/ubuntu-server-12042-x64-vbox4210-nocm.box'}
+    let(:local_box_uri) {"#{Dir.pwd}/spec/fixtures/test_box.box"}
+    let(:bebox_boxes_path) {File.expand_path(Bebox::ProjectWizard::BEBOX_BOXES_PATH)}
+
+    it 'should check project existence' do
+      output = subject.project_exists?(parent_path, project_name)
+      expect(output).to eq(false)
+    end
+
+    it 'should setup the bebox boxes directory' do
+      subject.bebox_boxes_setup
+      expect(Dir.exist?("#{bebox_boxes_path}/tmp")).to eq(true)
+      expect(Dir["#{bebox_boxes_path}/tmp/*"].count).to eq(0)
+    end
+
+    it 'should validate an http box uri' do
+      output = subject.uri_valid?(http_box_uri)
+      expect(output).to eq(true)
+    end
+
+    it 'should validate a local-file box uri' do
+      output = subject.uri_valid?(local_box_uri)
+      expect(output).to eq(true)
+    end
+
+    # it 'should download an http box' do
+    #   VCR.use_cassette('box_download') do
+    #     subject.set_box(http_box_uri)
+    #   end
+    #   expect(File.exist?("#{bebox_boxes_path}/ubuntu-server-12042-x64-vbox4210-nocm.box")).to eq(true)
+    # end
+
+    it 'should link a local file box' do
+      subject.set_box(local_box_uri)
+      expect(File.symlink?("#{bebox_boxes_path}/test_box.box")).to eq(true)
+    end
+  end
+end

data/spec/puppet_spec_helper.rb

@@ -0,0 +1,15 @@
+RSpec.configure do |config|
+  config.before do
+    host = 'node0.server1.test'
+    if config.host != host
+      config.disable_sudo = true
+      config.ssh.close if config.ssh
+      config.host  = host
+      options = Net::SSH::Config.for(config.host)
+      options[:keys] = ["#{puppet.project_root}/config/keys/environments/vagrant/id_rsa"]
+      options[:forward_agent] = true
+      user = 'puppet'
+      config.ssh   = Net::SSH.start(config.host, user, options)
+    end
+  end
+end

data/spec/role_profiles_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require_relative '../spec/factories/role.rb'
+require_relative '../spec/factories/profile.rb'
+
+describe 'Test 09: Associate roles and profiles' do
+
+  let(:role) { build(:role) }
+  let(:profile) { build(:profile) }
+
+  before :all do
+    role.create
+    profile.create
+  end
+
+  context 'add profiles' do
+    it 'should add a profile to a role' do
+      role_content = "include profiles::#{profile.namespace_name}"
+      Bebox::Role.add_profile(role.project_root, role.name, profile.relative_path)
+      output_file = File.read("#{role.path}/manifests/init.pp").strip
+      expect(output_file).to include(role_content)
+    end
+  end
+
+  context 'list profiles' do
+    it 'should list profiles' do
+      current_profiles = [profile.relative_path]
+      profiles = Bebox::Role.list_profiles(role.project_root, role.name)
+      expect(profiles).to include(*current_profiles)
+    end
+  end
+
+  context 'remove profiles' do
+    it 'should delete profile in a role' do
+      role_content = "include profiles::#{profile.namespace_name}"
+      Bebox::Role.remove_profile(role.project_root, role.name, profile.relative_path)
+      output_file = File.read("#{role.path}/manifests/init.pp").strip
+      expect(output_file).to_not include(role_content)
+    end
+  end
+end