BootingE's Engineering Blog

Hadoop Basic

Fri, 12 Feb 2016 00:00:00 +0000

-5x +5x

django-start

Sat, 11 Jul 2015 00:00:00 +0000

Commands

Virtual Environment로 시작하기 mkdir ~/Work/new_project cd ~/Work/new_project $ virtualenv venv $ source venv/bin/activate

load_testing

Fri, 10 Jul 2015 00:00:00 +0000

Load Testing Tools

Grinder

Key Features

TCP proxy - records network activity into the Grinder test script
Distributed testing - can scale with the increasing number of agent instances
Power of Python or Closure combined with any Java API for test script creation or modification
Flexible parameterization which includes creating test data on-the-fly and the capability to use external data sources like files, databases, etc.
Post processing and assertion - full access to test results for correlation and content verification
Support of multiple protocols

Gatling

Key Features

HTTP Recorder
An expressive self-explanatory DSL for test development
Scala-based
Produces higher load by using an asynchronous non-blocking approach
Full support of HTTP(S) protocols & can also be used for JDBC and JMS load testing
Multiple input sources for data-driven tests
Powerful and flexible validation and assertions system
Comprehensive informative load reports

Tsung

Key Features

Distributed by design
High performance. Underlying multithreaded-oriented Erlang architecture enables the simulation of thousands of virtual users on mid-end developer machines
Support of multiple protocols
A test recorder which supports HTTP and Postgres
OS monitoring. Both the load generator and application under the test operating system metrics can be collected via several protocols
Dynamic scenarios and mixed behaviours. The flexible load scenarios definition mechanism allows for any number of load patterns to be combined in a single test
Post processing and correlation
External data sources for data driven testing
Embedded easy-readable load reports which can be collected and visualized during load

JMeter

Key Features

Cross-platform. JMeter can be run on any operating system with Java
Scalable. When you need to create a higher load than a single machine can create, JMeter can be executed in a distributed mode - meaning one master JMeter machine will control a number of remote hosts.
Multi-protocol support. The following protocols are all supported ‘out-of-the-box’: HTTP, SMTP, POP3, LDAP, JDBC, FTP, JMS, SOAP, TCP
Multiple implementations of pre and post processors around sampler. This provides advanced setup, teardown parametrization and correlation capabilities
Various assertions to define criteria
Multiple built-in and external listeners to visualize and analyze performance test results
Integration with major build and continuous integration systems - making JMeter performance tests part of the full software development life cycle

Writing Plan

Fri, 03 Jul 2015 00:00:00 +0000

Fullstack Development with Python

Infra

Vagrant

Docker

Command
Container Management

Network

Netfilter
DNS
NAT
DHCP

Protocol

TCP
UDP
HTTP
SPDY
HTTP2
SSL

Proxy

Load Balancer

HA Proxy

Reverse Proxy

Squid
Nginx
Varnish
ATS

HA

WebServer

Apache
Nginx
Lighthttpd

WSGI Server

WAS

Django

ORM
Admin
RestFramework
OAuth
JWT

Flask

Async Programming

gevent
twisted

Task Queue

celery

WebSocket

authbahn
async.io

DB

RDB

MySQL

NoSQL

Memcached
Redis
Cassandra
MongoDB

Front-End

Framework

jQuery
Bootstrap
Foundation
AngularJS
React
Polymer

Chart

Graphics

opencv
imagemagick
html5 canvas

Hybrid App

ionic

Logging

Logger

Crash Logging

Pin Point

Monitoring

Performance Monitoring

Testing

Unit Testing

Unittest
Nosetest
BDD?

UI Testing

Selenium

Performance

YSlow
PageSpeed
How to caching
Optimization

Build & Deployment

buildout
Grunt
Bower
Django Pipeline
Fabric

Configuration Management

Puppet

Chef

SaltStack

Ansible

Continuous Integration

Debugging

GDB
PDB
Strace

Documentation

Sphinx
docstring

Welcome to Jekyll!

Mon, 29 Jun 2015 09:52:30 +0000

You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.

To add new posts, simply add a file in the _posts directory that follows the convention YYYY-MM-DD-name-of-post.ext and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll’s dedicated Help repository.

Automated Testing with Selenium

Mon, 29 Jun 2015 00:00:00 +0000

UI Testing

Selenium

Selenium automates browsers!!!

Features

navigate (windows, frames, links)
find elements and parse attributes
interact and trigger events (click, type, ...)
capture screenshots
run javascript
let the browser take care of the hard stuff(cookies, javascript, sessions, profiles, DOM)

Parts of Selenium

Selenium Webdriver
Selenium IDE
Selenium Server
Selenium-Grid

Commands

find

find_element_by_id
find_element_by_name
find_element_by_xpath
find_element_by_link_text
find_element_by_partial_link_text
find_element_by_tag_name
find_element_by_class_name
find_element_by_css_selector

def login_field(self):
    return self.wait.until(EC.element_to_be_clickable((By.NAME, 'Login')))

def password_field(self):
    return self.wait.until(EC.element_to_be_clickable((By.NAME, 'Password')))

def login_button(self):
    return self.wait.until(EC.element_to_be_clickable((By.XPATH, "//button[@type='submit']")))

def error_message(self):
    return self.wait.until(EC.element_to_be_clickable((By.XPATH, "//div[@class='error-text']")))

def login_username(self):
    return self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, "username")))

def logout_button(self):
    return self.wait.until(EC.element_to_be_clickable((By.CLASS_NAME, "logout")))

interact

def login(self, name, password):
    self.login_field().send_keys(name)
    self.password_field().send_keys(password)
    self.login_button().click()

Actions

actions = ActionChains(driver)
test_plan = wait.until(EC.presence_of_element_located((By.XPATH, ".//ul/li[1]"))) actions.move_to_element(test_plan)
actions.click(test_plan)
actions.perform()

Asserts

assertEqual(a, b)
assertNotEqual(a, b)
assertTrue(x)
assertFalse(x)

General Recipe

Install requirements $ pip install selenium pyvirtualdisplay
Start up Firefox and Selenium IDE or You can create a test code in your editor.
Record a 'test' run through site.
Export test as python script
Hack from there
- Loops
- Image/data extraction
- Wrangling data into a database

Running Selenium Server

$ java -jar selenium-server-standalone-2.x.x.jar

Selenium Script Example

http://selenium-python.readthedocs.org/en/latest/getting-started.html

import unittest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys

class PythonOrgSearch(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Firefox()

    def test_search_in_python_org(self):
        driver = self.driver
        driver.get("http://www.python.org")
        self.assertIn("Python", driver.title)
        elem = driver.find_element_by_name("q")
        elem.send_keys("pycon")
        elem.send_keys(Keys.RETURN)
        assert "No results found." not in driver.page_source


    def tearDown(self):
        self.driver.close()

if __name__ == "__main__":
    unittest.main()

Openstack Horizon

Mon, 29 Jun 2015 00:00:00 +0000

horizon

프로젝트 구성

의존성

Depencencies	설명
pbr	injects some useful and sensible default behaviors into your setuptools run
Babel	Babel is an internationalization library for Python
Django	Web Framework
Pint	Python package to define, operate and manipulate physical quantities
django_compressor	static 파일 compressor
django_openstack_auth	openstack auth 모듈
django-pyscss	django scss(stylesheet) 프레임워크
eventlet	비동기 I/O 프로그래밍 라이브러리
httplib2	http 통신 모듈
iso8601	날짜 모듈
kombu	Kombu is a messaging library for Python.
netaddr	네트워크 주소 모듈
oslo.*	OpenStack 관련 모듈
pyScss	compiler for the Sass language
pytz	WorldWide Timezone 모듈
PyYAML	YAML implementations for Python
six	Python 2 and 3 compatibility library
XStatic	tatic file packages with minimal overhead
XStatic-Angular
XStatic-Angular-Bootstrap
XStatic-Angular-lrdragndrop	A drag and drop module for angularjs
XStatic-Bootstrap-Datepicker
XStatic-Bootstrap-SCSS
XStatic-D3	Graphics Library
XStatic-Hogan	Twitter related Library.
XStatic-Font-Awesome
XStatic-Jasmine	BDD Framework
XStatic-jQuery
XStatic-JQuery-Migrate
XStatic-JQuery.quicksearch	A jQuery based plug-in for filtering large data sets with user input
XStatic-JQuery.TableSorter	Flexible client-side table sorting
XStatic-jquery-ui
XStatic-JSEncrypt	RSA Encrypt/Decrypt Library
XStatic-Magic-Search	AngularJS directive that provides a UI for both faceted filtering and as-you-type filtering
XStatic-QUnit	Javascript Unit Test Framework
XStatic-Rickshaw	JavaScript toolkit for creating interactive time-series graphs and charts.
XStatic-smart-table	Smart table is a table module for angular js
XStatic-Spin
XStatic-term.js	A terminal written in javascript.

파일 설명

manifest.in : Specifying the files to distribute.

디렉토리 구조

.
├── doc                               # Sphinx Documentation
├── horizon                           # Django Base Path
│   ├── browsers                  # Resource Browser(?)
│   ├── conf
│   │   ├── dash_template
│   │   └── panel_template
│   ├── contrib                       # 국제 시간 관련 유틸.
│   ├── forms                     # From Controller
│   ├── locale                        # 국제화.
│   ├── management                    # manage.py에 관리 명령을 추가
│   │   └── commands              # startdash, startpanel 명령 정의 클래스.
│   ├── static                        # Static Files
│   ├── tables
│   ├── tabs
│   ├── templates                 # View Files
│   ├── templatetags              # Filters for template
│   ├── test                      # Test Cases
│   ├── utils
│   └── workflows             # A Workflow is a collection of Steps.
├── openstack_dashboard               # App Folder
│   ├── api               # Rest API와 관련된 폴더.
│   │   └── rest          # API의 Controller에 해당하는 부분.
│   ├── conf
│   ├── dashboards        # 각 구성요소에 대한 대시보드 부분.
│   │   ├── admin
│   │   ├── identity
│   │   ├── project       # 프로젝트에 대한 대시보드(Model, View, Controller)
│   │   ├── router
│   │   └── settings
│   ├── django_pyscss_fix
│   ├── enabled
│   ├── local
│   │   └── enabled
│   ├── locale                        # 국제화
│   ├── management        # manage.py에 관리 명령을 추가
│   │   └── commands      # nginx, apache, wsgi 관련 명령도 추가.
│   ├── openstack         # 공통 유틸리티들.
│   │   └── common
│   ├── static                        # Static Files
│   ├── templates
│   ├── templatetags          # Filters for template
│   ├── test                        # Test Cases
│   ├── usage             # 사용량에 대한 View를 제공.
│   ├── utils
│   └── wsgi
└── tools                         # Virtual Envronment 구성 툴.

How to use fabric.

Mon, 29 Jun 2015 00:00:00 +0000

배포

Fabrid

Command-Line Tool
Streaming the use of SSH for application deployment or systems administration tasks.
Less codes than shell script
Less mistakes than handwork
Less time to operate many servers.

Basics

Install
$ pip install fabric
Setting(Make fabfile.py)
def hello(who="world"): print "Hello {who}!".format(who=who)
Run
$ fab hello:who=Fab

Running a command on remote hosts

Setting(Make fabfile.py)
from fabric.api import * env.hosts=["irteam@10.77.0.1", "10.77.0.2"] env.user="irteam" env.password="password" env.parallel=True def hostname_check(): run("hostname") def command(cmd): run(cmd)
Run
$ fab hostname_check $ fab command:date

Core Functionality

local() : Run a command locally
run() : Run a command remotely
sudo() : Run a command remotely as another user
put() : Copy a file from local to remote
get() : Copy a file from remote to local

Problems

Tailing log file (tail -f /var/log/messages) is difficult.

Fabrid SSH 설정

SSH 키를 사용해서 로그인한다면, SSH 키가 기본 위치에 있고, 서버와 동일 사용자명을 사용하는 한 Fabrid이 정상 동작해야 한다.

Examples

Django Registration and authentication

Mon, 29 Jun 2015 00:00:00 +0000

Django Registration 구현

Django에서 Registraion을 구현하는 방법을 설명
기본적인 회원 등록, E-mail Verification, 로그인 기능들을 제공함.
- Django Allauth 모듈을 사용함
- AllAuth에서는 Facebook, Google 등 다양한 서비스에 대한 OAuth 로그인을 제공함.
JWT(JSon Web Token) 기반의 인증 처리.
- django-rest-framework-jwt 사용.

Registration Form 만들기

Django Allauth 설치

폴더 내부에 example이 있음.

$ git clone git://github.com/pennersr/django-allauth.git
$ cd django-allauth/example
$ virtualenv venv
$ . venv/bin/activate
$ pip install -r requirements.txt

DB 생성하기

$ python manage.py syncdb

URL 설정하기

Allauth에서 사용하는 URL을 설정.
example/urls.py에 설정.

urlpatterns = patterns('',
                       (r'^accounts/', include('allauth.urls')),
                       ...
)

SMTP 서버 테스트하기

Registration 과정 중에 E-mail Verification이 있음.
Python의 기본 모듈을 통해서 임의의 SMTP 서버를 띄울 수 있음.
- 아래 명령어는 1025번 포트로 smtp 서버를 띄움

$ python -m smtpd -n -c DebuggingServer localhost:1025

settings.py에서 localhost, 1025번 포트로 설정을 변경하고 테스트.

EMAIL_HOST='localhost'
EMAIL_PORT=1025
EMAIL_HOST_USER=''
EMAIL_HOST_PASSWORD=''

Real SMTP 서버 설정하기

사용자가 회원 가입한 e-mail verification 서버 변경.
SMTP 서버 정보를 변경해야 함.
example/settings.py 내부 설정 변경 .

$ pip install django-smtp-ssl

사용할 SMTP 서버 정보 설정.

EMAIL_BACKEND = 'django_smtp_ssl.SSLEmailBackend'
EMAIL_USE_TLS = True
EMAIL_HOST = 'smtp.daum.net'
EMAIL_PORT = 465
EMAIL_HOST_USER = 'ADMIN_ID'
EMAIL_HOST_PASSWORD = 'ADMIN_PASSWORD'
DEFAULT_FROM_EMAIL = 'Verified-email <admin@localhost>'

SSL을 사용하는 SMTP 서버는 django.core.mail.backends.smtp.EmailBackend를 사용하면 동작하지 않았음.

실행하기

$ python manage.py runserver

여기까지 진행하면, 기본적인 회원 Registration, Login은 가능함.

JWT(JSON Web Token) 설정

설치하기

Django Rest Framework 및 JWT 모듈 설치.

$ pip install djangorestframework
$ pip install djangorestframework-jwt

설정하기

Rest Framework에 대한 설정(settings.py)

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    ),
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication',
        'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
    ),
}

INSTALLED APPS에 Rest Framework 추가.

INSTALLED_APPS = (
  ...
  'rest_framework',
  ...
)

URL 및 View 설정하기.

from django.contrib.auth.models import User
from rest_framework import routers, serializers, viewsets

# Serializers define the API representation.
class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = ('url', 'username', 'email', 'is_staff')

# ViewSets define the view behavior.
class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer

# Routers provide an easy way of automatically determining the URL conf.
router = routers.DefaultRouter()
router.register(r'users', UserViewSet)

example/urls.py의 urlpatterns에 추가.

url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
url(r'^api-token-auth/', 'rest_framework_jwt.views.obtain_jwt_token'),
url(r'^api-token-refresh/', 'rest_framework_jwt.views.refresh_jwt_token'),
url(r'^api-token-verify/', 'rest_framework_jwt.views.verify_jwt_token'),

테스트하기

Login.

JSON으로 ID와 PW를 전달하면 JSON Web Token를 얻을 수 있음.

$ curl -X POST -H "Content-Type: application/json" -d '{"username":"admin","password":"admin"}' http://127.0.0.1:8000/api-token-auth/

실행 결과 얻어진 JSON Web Token

{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIiwidXNlcl9pZCI6MSwiZW1haWwiOiJhZG1pbkBuYXZlci5jb20iLCJleHAiOjE0MzU1MDY3NzF9.dsqiJDuJPCifRm0wt3qCdgQnuZSZYvIDeZQmCH62D1A"}%

Token Verification

얻은 JWT가 유효한지를 체크.
- 정상적으로 호출됐으면 호출한 Token을 반환함.

$ curl -X POST -H "Content-Type: application/json" -d '{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIiwidXNlcl9pZCI6MSwiZW1haWwiOiJhZG1pbkBuYXZlci5jb20iLCJleHAiOjE0MzU1MDY3NzF9.dsqiJDuJPCifRm0wt3qCdgQnuZSZYvIDeZQmCH62D1A"}' http://127.0.0.1:8000/api-token-verify/

접근 제한된 URL 추가하기.

example/demo/views.py에 추가.

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated

from rest_framework_jwt.authentication import JSONWebTokenAuthentication

class RestrictedView(APIView):
    permission_classes = (IsAuthenticated, )
    authentication_classes = (JSONWebTokenAuthentication, )

    def get(self, request):
        data = {
            'id': request.user.id,
            'username': request.user.username,
            'token': str(request.auth)
        }
        return Response(data)

example/urls.py의 urlpatterns에 추가.

from example.demo.views import RestrictedView
...
urlpatterns = patterns('',
  ...
  url(r'^restricted/$', RestrictedView.as_view()),
  ...
)

테스트하기

$ curl -H "Authorization: JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIiwidXNlcl9pZCI6MSwiZW1haWwiOiJhZG1pbkBuYXZlci5jb20iLCJleHAiOjE0MzU1MDgwNjJ9.Zd9MSdA41HYJTAjW7JEMsK3TUv5EYXAj5X0S1IdKwFY" http://127.0.0.1:8000/restricted/

참고

Django-Rest-Auth

사이트
Django에 Rest Framework와 Auth를 연동시켜둔 모듈
Demo Project를 따라해보면, 어떤식으로 페이지를 구성할 수 있을지 알 수 있음.

Django-Rest-Auth with AngularJS

사이트
- AngularJS와 Django-Rest-Auth를 결합한 샘플 프로젝트

참고 : CORS 오류(Access-Control-Allow-Origin) 발생시.
- settings.py에 추가
CORS_ORIGIN_ALLOW_ALL = True INSTALLED_APPS = ( ... 'corsheaders', ... ) MIDDLEWARE_CLASSES = ( ... 'corsheaders.middleware.CorsMiddleware', ... )

Django Mocking

Mon, 29 Jun 2015 00:00:00 +0000

Mocking in Python

Mocking makes unit testing easier!!!

Great Unit Testing Myths

They’re good when the problem is easy.
I spend too much time writing lots of code to test, so I give up
There’s just some stuff you can’t unit test.

What are Mocks?

Test Double

Dummy Object
Test Stub
- Provide a canned response to method calls
Test Spy
- Real objects that behave like normal except when a specific condition is met
Mock Object
- Provide a canned response to method calls
Fake Object

Quick Guide

http://mock.readthedocs.org/en/latest/

Mock, MagicMock

Mock and MagicMock objects create all attributes and methods as you access them and store details of how they have been used.

>>> from mock import MagicMock
>>> thing = ProductionClass()
>>> thing.method = MagicMock(return_value=3)
>>> thing.method(3, 4, 5, key='value')
3
>>> thing.method.assert_called_with(3, 4, 5, key='value')

side_effect

side_effect allows you to perform side effects, including raising an exception when a mock is called

>>> mock = Mock(side_effect=KeyError('foo'))
>>> mock()
Traceback (most recent call last):
 ...
KeyError: 'foo'

>>> values = {'a': 1, 'b': 2, 'c': 3}
>>> def side_effect(arg):
...     return values[arg]
...
>>> mock.side_effect = side_effect
>>> mock('a'), mock('b'), mock('c')
(1, 2, 3)
>>> mock.side_effect = [5, 4, 3, 2, 1]
>>> mock(), mock(), mock()
(5, 4, 3)

patch

The patch() decorator / context manager makes it easy to mock classes or objects in a module under test.
The object you specify will be replaced with a mock (or other object) during the test and restored when the test ends

>>> from mock import patch
>>> @patch('module.ClassName2')
... @patch('module.ClassName1')
... def test(MockClass1, MockClass2):
...     module.ClassName1()
...     module.ClassName2()

...     assert MockClass1 is module.ClassName1
...     assert MockClass2 is module.ClassName2
...     assert MockClass1.called
...     assert MockClass2.called
...
>>> test()

Example - Fear System Calls

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os

def rm(filename):
    os.remove(filename)

TestCase without Mock

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import rm

import os.path
import tempfile
import unittest

class RmTestCase(unittest.TestCase):

    tmpfilepath = os.path.join(tempfile.gettempdir(), "tmp-testfile")

    def setUp(self):
        with open(self.tmpfilepath, "wb") as f:
            f.write("Delete me!")

    def test_rm(self):
        # remove the file
        rm(self.tmpfilepath)
        # test that it was actually removed
        self.assertFalse(os.path.isfile(self.tmpfilepath), "Failed to remove the file.")

Testcase with Mock

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import rm

import mock
import unittest

class RmTestCase(unittest.TestCase):

    @mock.patch('mymodule.os')
    def test_rm(self, mock_os):
        rm("any path")
        # test that rm called os.remove with the right parameters
        mock_os.remove.assert_called_with("any path")

Adding Validation to 'rm'

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import os.path

def rm(filename):
    if os.path.isfile(filename):
        os.remove(filename)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import rm

import mock
import unittest

class RmTestCase(unittest.TestCase):

    @mock.patch('mymodule.os.path')
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os, mock_path):
        # set up the mock
        mock_path.isfile.return_value = False

        rm("any path")

        # test that the remove call was NOT called.
        self.assertFalse(mock_os.remove.called, "Failed to not remove the file if not present.")

        # make the file 'exist'
        mock_path.isfile.return_value = True

        rm("any path")

        mock_os.remove.assert_called_with("any path")

We now can verify and validate internal functionality of methods without any side-effects.

File-Removal as a Service

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import os.path

class RemovalService(object):
    """A service for removing objects from the filesystem."""

    def rm(filename):
        if os.path.isfile(filename):
            os.remove(filename)

Tetscase for Service

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from mymodule import RemovalService

import mock
import unittest

class RemovalServiceTestCase(unittest.TestCase):

    @mock.patch('mymodule.os.path')
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os, mock_path):
        # instantiate our service
        reference = RemovalService()

        # set up the mock
        mock_path.isfile.return_value = False

        reference.rm("any path")

        # test that the remove call was NOT called.
        self.assertFalse(mock_os.remove.called, "Failed to not remove the file if not present.")

        # make the file 'exist'
        mock_path.isfile.return_value = True

        reference.rm("any path")

        mock_os.remove.assert_called_with("any path")

테스트시 주의할 점.

시나리오 기반 테스트

testscenarios 모듈을 기반으로 한 테스트를 하지 말것.

Edit 2/7/2012: This is a moderately bad approach to the problem. While an interesting hack I highly discourage using this in a production environment. If you want this approach in python I recommend checking out the lettuce project for a much more sane approach.

Cucumber 사용

Cucumber를 사용할 경우 feature 문서를 변경하면 StepDefinitions 소스 코드까지 수정해야 하기 때문에 유지보수 비용이 좀 발생할 듯하다.
프로그래머 레벨에서는 cucumber를 사용하지 마라. > - 많은 프로그래머들이 cucumber를 integration test로 잘못 사용하고 있다.
- cucumber의 용도는 보다 하이 레벨의 분석툴이며, 이를 acceptance test용으로 사용하기에는 프로그래머 입장에선 불편한 점이 많다.
- 당신이 프로그래머라면 cucumber를 integration test로 사용하면서 불편하게 살지 말고, 그럴 바에야 acceptance test 안한다는거 인정하고 Capybara 같은 pure integration test 도구를 사용해라.