diff --git a/.kitchen.openstack.yml b/.kitchen.openstack.yml
deleted file mode 100644
index a1d32da..0000000
--- a/.kitchen.openstack.yml
+++ /dev/null
@@ -1,44 +0,0 @@
----
-# https://docs.chef.io/config_yml_kitchen.html
-
-driver:
-  # OPENSTACK API
-  # https://github.com/test-kitchen/kitchen-openstack
-  name: openstack
-  openstack_auth_url: <%= ENV['OS_AUTH_URL'] %>/tokens
-  openstack_username: <%= ENV['OS_USERNAME'] || 'ci' %>
-  openstack_api_key:  <%= ENV['OS_PASSWORD'] || 'ci' %>
-  openstack_tenant:   <%= ENV['OS_TENANT_NAME'] || 'ci_jenkins' %>
-
-  #floating_ip_pool: <%= ENV['OS_FLOATING_IP_POOL'] || 'nova' %>
-  #key_name: <%= ENV['BOOTSTRAP_SSH_KEY_NAME'] || 'id_ed25519' %>
-  key_name: <%= ENV['BOOTSTRAP_SSH_KEY_NAME'] || 'bootstrap_insecure' %>
-  private_key_path: <%= ENV['BOOTSTRAP_SSH_KEY_PATH'] || "#{ENV['HOME']}/.ssh/id_rsa_bootstrap_insecure" %>
-
-  require_chef_omnibus: false         #[e.g. 'true' or a version number if you need Chef]
-
-
-platforms:
-  - name: ubuntu-14.04
-    driver:
-      username: <%= ENV['OS_UBUNTU_IMAGE_USER'] || 'root' %>
-      image_ref: <%= ENV['OS_UBUNTU_IMAGE_REF'] || 'ubuntu-14-04-x64-1455869035' %>
-      flavor_ref: m1.medium
-      network_ref:
-        <% if ENV['OS_NETWORK_REF'] -%>
-        - <% ENV['OS_NETWORK_REF'] %>
-        <% else -%>
-        - ci-net
-        <% end -%>
-    # force update apt cache on the image
-    run_list:
-      - recipe[apt]
-    attributes:
-      apt:
-          compile_time_update: true
-transport:
-  username: <%= ENV['OS_UBUNTU_IMAGE_USER'] || 'root' %>
-
-
-# vim: sw=2 ts=2 sts=2 tw=125
-## EXAMPLES, dynamic kitchen driver, http://stackoverflow.com/questions/26516373/alternate-drivers-with-test-kitchen
diff --git a/.kitchen.vagrant.yml b/.kitchen.vagrant.yml
deleted file mode 100644
index da81168..0000000
--- a/.kitchen.vagrant.yml
+++ /dev/null
@@ -1,30 +0,0 @@
----
-driver:
-  name: vagrant
-  vm_hostname: logrotate.ci.local
-  use_sudo: false
-  customize:
-    memory: 512
-
-
-provisioner:
-  name: salt_solo
-  salt_install: bootstrap
-  salt_bootstrap_url: https://bootstrap.saltstack.com
-  salt_version: latest
-  require_chef: false
-  formula: logrotate
-  log_level: info
-  state_top:
-    base:
-      "*":
-        - logrotate
-  pillars:
-    top.sls:
-      base:
-        "*":
-          - logrotate
-  grains:
-    noservices: True
-
-# vim: ft=yaml sw=2 ts=2 sts=2 tw=125
