def get(self,url,headers={}):
        "Mechanize Get request"
        browser = self.get_browser()
        request_headers = []
        response = {}
        error = {}
        for key, value in headers.iteritems():
            request_headers.append((key, value))
            browser.addheaders = request_headers
        try:
            response = browser.open(mechanize.Request(url))
            response = json.loads(response.read())
        except (mechanize.HTTPError, mechanize.URLError) as e:
            error = e
            if isinstance(e, mechanize.HTTPError):
                error_message = e.read()
                print("\n******\GET Error: %s %s" %
                (url, error_message))
            else:
                print(e.reason.args)
            # bubble error back up after printing relevant details
                raise e
 
        return {'response':response,'error':error}

"""
API endpoints for Registration 
"""
from Base_Mechanize import Base_Mechanize
class Registration_API_Endpoints(Base_Mechanize):
	"Class for registration endpoints"
 
	def registration_url(self,suffix=''):
		"""Append API end point to base URL"""
		return self.base_url+'/register/'+suffix
 
 
	def register_car(self,url_params,data,headers):
		"register car "
		url = self.registration_url('car?')+url_params
		json_response = self.post(url,data=data,headers=headers)
		return {
			'url':url,
			'response':json_response['response'].read()
		}

"""
A composed interface for all the API objects
Use the API_Player to talk to this class
"""
from Cars_API_Endpoints import Cars_API_Endpoints
from Registration_API_Endpoints import Registration_API_Endpoints
from User_API_Endpoints import User_API_Endpoints
 
class API_Interface(Cars_API_Endpoints,Registration_API_Endpoints,User_API_Endpoints):
	"A composed interface for the API objects"
 
	def __init__(self, url):
		"Constructor"
		# make base_url available to all API endpoints
		self.base_url = url

class API_Player(Results):
    "The class that maintains the test context/state"
 
    def __init__(self, url, log_file_path=None):
        "Constructor"
        super(API_Player, self).__init__(
            level=logging.DEBUG, log_file_path=log_file_path)
        self.api_obj = API_Interface(url=url)    
 
    def set_auth_details(self, username, password):
        "encode auth details"
        user = username
        password = password
        b64login = b64encode('%s:%s' % (user, password))
 
        return b64login
 
    def set_header_details(self, auth_details=None):
        "make header details"
        if auth_details != '' and auth_details is not None:
            headers = {'content-type': 'application/json',
                       'Authorization': 'Basic %s' % auth_details}
        else:
            headers = {'content-type': 'application/json'}
 
        return headers
 
    def get_cars(self, auth_details=None):
        "get available cars "
        headers = self.set_header_details(auth_details)
        json_response = self.api_obj.get_cars(headers=headers)
        json_response = json_response['response']
        result_flag = True if json_response['successful'] is True else False
        self.write(msg="Fetched cars list:\n %s"%str(json_response))
        self.conditional_write(result_flag,
                               positive="Fetched cars",
                               negative="Could not fetch cars")
 
        return json_response

 # add cars
        car_details = conf.car_details
        result_flag = test_obj.add_car(car_details=car_details,
                                       auth_details=auth_details)
        test_obj.log_result(result_flag,
                            positive='Successfully added new car with details %s' % car_details,
                            negative='Could not add new car with details %s' % car_details)
        # test for validation http error 403
        result = test_obj.check_validation_error(auth_details)
        test_obj.log_result(not result['result_flag'],
                            positive=result['msg'],
                            negative=result['msg'])

    def register_car(self, car_name, brand, auth_details=None):
        "register car"
        url_params = {'car_name': car_name, 'brand': brand}
        url_params_encoded = urllib.urlencode(url_params)
        customer_details = conf.customer_details
        data = customer_details
        headers = self.set_header_details(auth_details)
        json_response = self.api_obj.register_car(url_params=url_params_encoded,
                                                  data=json.dumps(data),
                                                  headers=headers)
        response = json.loads(json_response['response'])
        result_flag = True if response['registered_car']['successful'] == True else False
 
        return result_flag
 
    def check_validation_error(self, auth_details=None):
        "verify validatin error 403"
        result = self.get_user_list(auth_details)
        user_list = result['user_list']
        response_code = result['response_code']
        result_flag = False
        msg = ''
 
        "verify result based on user list and response code"
        if user_list is None and response_code == 403:
            msg = "403 FORBIDDEN: Authentication successful but no access for non admin users"
 
        elif response_code == 200:
            result_flag = True
            msg = "successful authentication and access permission"
 
        elif response_code == 401:
            msg = "401 UNAUTHORIZED: Authenticate with proper credentials OR Require Basic Authentication"
 
        elif response_code == 404:
            msg = "404 NOT FOUND: URL not found"
 
        else:
            msg = "unknown reason"
 
        return {'result_flag': result_flag, 'msg': msg}