예제 #1
0
 def post(self, request):
     data = request.DATA
     try:
         username = data["username"]
         password = data["password"]
     except KeyError as e:
         return Response({"error": "Invalid object."},
                         status=status.HTTP_400_BAD_REQUEST,
                         exception=True)
     #todo: validate username and password
     user = User.objects.create_user(username = username, password = password)
     new_user = AppUser(user = user, app = request.app)
     try:
         new_user.full_clean()
     except ValidationError as e:
         return Response(e.message_dict, status=status.HTTP_400_BAD_REQUEST)
     
     new_user.save()
     user = authenticate(username=username, password=password)
     login(request, user)
     request.session.save()
     return Response({settings.SESSION_COOKIE_NAME : request.session.session_key,
                       "id" : user.id
                     },
                     status=status.HTTP_201_CREATED)
예제 #2
0
def create_recipe():
    data = request.get_json()
    recipe = data.get("recipe")
    owner = data.get("owner")

    user = AppUser.query.filter(AppUser.name == owner).first()

    if user is None:
        user = AppUser(name=owner)
        try:
            user.insert()
        except:
            abort(422)

    title = recipe.get("recipeTitle")
    ingredients = json.dumps(recipe.get("ingredients", ""))
    instructions = recipe.get("instructions")
    recipe = Recipe(title=title, ingredients=ingredients, instructions=instructions, owner_id=user.id)

    try:
        recipe.insert()
    except:
        abort(422)

    return jsonify({
        "success": True,
        "recipe": recipe.long(),
    })
예제 #3
0
    def setUp(self):
        self.testbed = testbed.Testbed()
        self.testbed.activate()
        self.testbed.init_datastore_v3_stub()
        self.testbed.init_memcache_stub()

        self.existing_app_user = users.User('*****@*****.**')
        AppUser(user=self.existing_app_user, email='*****@*****.**').put()
        self.new_app_user = users.User('*****@*****.**')

        AppUser.date_acquired._auto_now = False  # override for testing purposes

        self.old_user = users.User('*****@*****.**')
        AppUser(user=self.old_user,
                email='*****@*****.**',
                refresh_token='should not exist',
                date_acquired=datetime.datetime(2000, 1, 1)).put()

        AppUser.date_acquired._auto_now = True

        self.recent_user = users.User('*****@*****.**')
        AppUser(user=self.recent_user,
                email='*****@*****.**',
                refresh_token='should exist').put()

        app_credential = AppCredential(client_id='1', client_secret='secret')
        app_credential.put()
예제 #4
0
 def post(self, request):
     try:
         #todo: update first_name, last_name and other attributes
         stream = StringIO.StringIO(request.body)
         data = JSONParser().parse(stream)
         username = data["username"]
         password = data["password"]
         
     except Exception as e:
         self.logger.error("Unable to decode object. Error: %s"%str(e))
         return Response({"detail": "Invalid object."},
                         status=status.HTTP_400_BAD_REQUEST,
                         exception=True)
     app =  request.META['app']
     #todo: validate username and password
     user = User.objects.create_user(username = username, password = password)
     new_user = AppUser(user = user, app = app)
     try:
         new_user.full_clean()
     except ValidationError as e:
         return Response(e.message_dict, status=status.HTTP_400_BAD_REQUEST)
     
     new_user.save()
     user = authenticate(username=data["username"], password=data["password"])
     login(request, user)
     request.session.save()
     return Response({settings.SESSION_COOKIE_NAME : request.session.session_key,
                       "id" : user.id
                     },
                     status=status.HTTP_201_CREATED)
예제 #5
0
def InitUser(refresh_token=None):
  """Initialize application user.

  Retrieve existing user credentials from datastore or add new user.
  If a refresh token is specified, it replaces the old refresh token and the
  date_acquired is updated as well.

  Args:
    refresh_token: str A new refresh token received from the auth flow.
                   Defaults to None.

  Returns:
    AppUser instance of the application user.
  """

  result = AppUser.query(
      AppUser.user == users.get_current_user()).fetch(limit=1)

  if result:
    # app_user exists
    app_user = result[0]
    if not app_user.refresh_token:
      # update refresh_token if provided in the arguments
      app_user.refresh_token = refresh_token
      app_user.date_acquired = datetime.datetime.now()
  else:
    app_user = AppUser(
        user=users.get_current_user(),
        email=users.get_current_user().email(),
        refresh_token=refresh_token)

  app_user.put()
  return app_user
예제 #6
0
    def testAppUser(self, ident='123', email='*****@*****.**', is_admin='0'):
        print ' --- App users tests --- '
        assert not users.get_current_user()

        self.testbed.setup_env(
            USER_EMAIL=email,
            USER_ID=ident,
            USER_IS_ADMIN=is_admin,
            overwrite=True)

        user = users.get_current_user()

        assert user.email() == email
        assert user.user_id() == ident

        app_user = AppUser(identity=user.user_id(), email=user.email())
        assert app_user.identity == user.user_id()
        assert app_user.email == user.email()

        app_user_key = app_user.put().urlsafe()

        retrieved_app_user = get_entity_memcache(app_user_key)
        assert retrieved_app_user is not None
        assert retrieved_app_user.identity == user.user_id()
        assert retrieved_app_user.email == user.email()

        product1 = Product(name='product1', cost=1)
        product2 = Product(name='product2', cost=2)
        product3 = Product(name='product3', cost=3)
        product1_key = product1.put().urlsafe()
        product2_key = product2.put().urlsafe()
        product3_key = product3.put().urlsafe()

        retrieved_product1 = get_entity_memcache(product1_key)
        retrieved_product2 = get_entity_memcache(product2_key)
        retrieved_product3 = get_entity_memcache(product3_key)

        app_user.add_product(retrieved_product1)
        app_user.add_product(retrieved_product2)
        app_user.add_product(retrieved_product3)

        assert len(app_user.products) > 0
        assert len(app_user.products) == 3

        app_user.remove_product(retrieved_product1)
        assert len(app_user.products) > 0
        assert len(app_user.products) == 2

        app_user.remove_product(retrieved_product2)
        app_user.remove_product(retrieved_product3)

        assert len(app_user.products) == 0
예제 #7
0
def register():
    """
    This view allows a user to register for the site.

    This will create a new User in Stormpath, and then log the user into their
    new account immediately (no email verification required).
    """
    if request.method == 'GET':
        if user.is_authenticated():
            return redirect(url_for('index'))

        return render_template('register.html')

    try:
        _user = stormpath_manager.application.accounts.create({
            'username':
            request.form.get('username'),
            'email':
            request.form.get('email'),
            'password':
            request.form.get('password'),
            'given_name':
            request.form.get('first_name'),
            'surname':
            request.form.get('last_name')
        })
        _user.__class__ = User

        app_user = AppUser(_user.get_id())
        db.session.add(app_user)
        db.session.commit()

    except StormpathError, err:
        return render_template('register.html', error=err.message)
예제 #8
0
def user_context(request):
    try:
        username = request.session['username']
        channel_logo = request.session['channel_logo']
        company_logo = request.session['company_logo']
        app_user = AppUser.get(username)
        fullname = app_user.user.get_full_name()
        site = Site.objects.get_current()

    except KeyError:
        channel_logo = "/static/images/logo-blue-transparent.png"
        company_logo = "/static/dimages/tilde.png"
        fullname = ''
        site = Site.objects.get()

    try:
        ga_code = ga_codes[site.name]
    except KeyError:
        ga_code = ga_codes['default']

    context = {
        'session': request.session, 
        'path': request.path, 
        'version': VERSION_STAMP,
        'fullname': fullname, 
        'channel_logo': channel_logo,
        'company_logo': company_logo,
        'site': site.name,
        'ga_code': ga_code,
    }
    callingframe = sys._getframe(1)
    logger.info( '\n----\n%r context %s\n--------', callingframe.f_code.co_name, context)
    return context
예제 #9
0
def user_context(request):
    try:
        username = request.session['username']
        channel_logo = request.session['channel_logo']
        company_logo = request.session['company_logo']
        app_user = AppUser.get(username)
        fullname = app_user.user.get_full_name()
        site = Site.objects.get_current()

    except KeyError:
        channel_logo = "/static/images/logo-blue-transparent.png"
        company_logo = "/static/dimages/tilde.png"
        fullname = ''
        site = Site.objects.get()

    try:
        ga_code = ga_codes[site.name]
    except KeyError:
        ga_code = ga_codes['default']

    context = {
        'session': request.session,
        'path': request.path,
        'version': VERSION_STAMP,
        'fullname': fullname,
        'channel_logo': channel_logo,
        'company_logo': company_logo,
        'site': site.name,
        'ga_code': ga_code,
    }
    callingframe = sys._getframe(1)
    logger.info('\n----\n%r context %s\n--------', callingframe.f_code.co_name,
                context)
    return context
예제 #10
0
 def testInitNewUser(self):
     users.get_current_user = mock.MagicMock(return_value=self.new_app_user)
     self.assertEqual(self.new_app_user, InitUser('new token').user)
     new_app_user_ndb = AppUser.query(
         AppUser.user == users.get_current_user()).fetch()[0]
     self.assertTrue(new_app_user_ndb)
     self.assertEqual('new token', new_app_user_ndb.refresh_token)
예제 #11
0
 def test_add_user(self):
     count = AppUser.query.count()
     res = self.client.post('/api/v1/user/add',
                            data=dict(email='*****@*****.**',
                                      username='******',
                                      password='******'))
     self.assertEqual(len(AppUser.get_all()), count + 1)
예제 #12
0
 def check_token(**kwargs):
     try:
         g.user_id = AppUser.verify_auth_token(request.headers.get('x-access-token'))
     except ValueError as err:
         print(err.args)
         abort(403)
     return func(**kwargs)
예제 #13
0
 def test_user_pw(self):
     res = self.client.post('/api/v1/user/add',
                            data=dict(email='*****@*****.**',
                                      username='******',
                                      password='******'))
     user = AppUser.get_by_id(json.loads(res.get_data()).get('id'))
     self.assertTrue(user.check_password('xxxx'))
예제 #14
0
    def get(self):
        user = users.get_current_user()
        products = []
        if user:
            url_linktext = 'Logout'
            # Función propia de la clase USER de App Engine
            url = users.create_logout_url(self.request.uri)
            # get_or_insert es una solución para obtener o crear un registro en caso de que
            # ya se encontrara guardado o no, respectivamente
            app_user = AppUser.get_or_insert(user.user_id(),
                                             identity=user.user_id(),
                                             email=user.email())

            keys = [ndb.Key(Product, int(k)) for k in app_user.products]
            if keys:
                products = ndb.get_multi(keys)
                products = filter(None, products)
        else:
            url = users.create_login_url(self.request.uri)
            url_linktext = 'Login'
        template = JINJA_ENVIRONMENT.get_template(VIEWS['index'])
        # A la función "render" se le pasa un diccionario de parámetros que se van a utilizar en la vista.
        # Estos parámetros vienen identificados por {{ }}
        self.response.write(
            template.render({'user': user, 'url': url, 'url_linktext': url_linktext, 'products': products}))
예제 #15
0
 def test_user_pw_fail(self):
     res = self.client.post('/api/v1/user/add',
                            data=dict(email='*****@*****.**',
                                      username='******',
                                      password='******'))
     print json.loads(res.get_data()).get('id')
     id = json.loads(res.get_data()).get('id')
     user = AppUser.get_by_id(id)
     self.assertFalse(user.check_password('xsssxxx'))
예제 #16
0
def createUser(login_session):
    print "inside createUser function"
    newUser = AppUser(name=login_session['username'],
                      email=login_session['email'],
                      picture=login_session['picture'])
    session.add(newUser)
    session.commit()
    print "returning user..."
    user = session.query(AppUser).filter_by(email=login_session['email']).one()
    print user.id
    return user.id
예제 #17
0
 def get(self):
     user = users.get_current_user()
     products = Product.query().order(Product.name)
     if user:
         app_user = AppUser.get_or_insert(get_user_key(user),
                                          identity=user.user_id(),
                                          email=user.email())
     else:
         return self.redirect(URLS['index'])
     template = JINJA_ENVIRONMENT.get_template(VIEWS['products'])
     self.response.write(template.render({'products': products, 'user': app_user}))
예제 #18
0
def register_user(request):
    user_exist = False
    if request.method == "POST":
        form = RegistrationForm(request.POST)
        if form.is_valid():
            name = request.POST['username']
            current_site = get_current_site(request)
            print current_site
            try:
                user_exist = User.objects.get(username=name)
                print "USER EXIST ---------", user_exist
            except ObjectDoesNotExist:
                password = request.POST['password1']
                user = User.objects.create_user(name,
                                                name,
                                                password,
                                                is_active=False)
                key = ''.join(
                    random.choice(string.digits + string.letters)
                    for _ in range(10))
                app_user = AppUser(user=user,
                                   key_expires=timezone.now() +
                                   datetime.timedelta(minutes=3),
                                   activation_key=key)
                app_user.save()
                # activation_key = key, to = ['*****@*****.**'])
                Thread(target=mail.registration_mail,
                       kwargs={
                           'host': current_site.domain,
                           'activation_key': key,
                           'to': ['*****@*****.**']
                       }).start()
                # mail.registration_mail(activation_key=key, to=['*****@*****.**'])
                print 'mail sent success --------'
                return HttpResponseRedirect(reverse('login'))
    else:
        form = RegistrationForm()
    return render(request, 'login/register.html', {
        'form': form,
        'user_exist': user_exist
    })
예제 #19
0
def RevokeOldCredentials():
  """Revoke old credentials.

  Find all users in the datastore with refresh tokens older than 30 days and
  revokes them.
  """
  users_with_expired_tokens = AppUser.query(
      AppUser.date_acquired <=
      datetime.datetime.now() - datetime.timedelta(30)).fetch()
  for expired_user in users_with_expired_tokens:
    expired_user.refresh_token = None
  ndb.put_multi(users_with_expired_tokens)
예제 #20
0
def get_app_user(db, team_id: int, slack_user_id: str, slack_user_name: str):
    assert isinstance(team_id, int)
    assert isinstance(slack_user_id, str)
    assert isinstance(slack_user_name, str)
    app_user = db.query(AppUser).filter(
        AppUser.team_id == team_id,
        AppUser.slack_user_id == slack_user_id).first()
    if app_user:
        app_user.slack_user_name = slack_user_name
    else:
        app_user = AppUser(team_id=team_id,
                           slack_user_id=slack_user_id,
                           slack_user_name=slack_user_name)
        db.add(app_user)
        db.flush()
    return app_user
def generate_report_xlsx(self, project_id, report_type):
    project = Project.get(Project.id == project_id)
    total_probes = len([p for p in project.project_stacks])
    project_users = AppUser.select().join(ProjectUser).where(ProjectUser.project == project)
    project_info = project.title.split('_')
    report = {}
    total_iteration = 0
    
    for iteration, project_stack in enumerate(project.project_stacks):
        stack = {}
        stack_images = StackImage.select().where(StackImage.stack == project_stack.stack.id)
        for stack_image in stack_images:
            users = {}
            for user in project_users:
                markers = Marker.select().where(
                                    Marker.app_user == user.id,
                                    Marker.stack_image == stack_image.id,
                                    Marker.project_stack == project_stack.id
                                )

                user_markers = [m.serialized for m in markers]
                if user_markers:
                    users[user.email] = user_markers
            stack[stack_image.image.name] = users

        report[project_stack.stack.title] = stack
        self.update_state(state='PROGRESS', meta={
            'current': iteration,
            'total': total_probes,
            'projectId': project_id,
            'reportType': report_type
        })
        total_iteration += 1
    
    return {
        'current': total_iteration,
        'total': total_probes,
        'status': 'Task complete',
        'projectId': project_id,
        'report': report,
        'reportType': report_type
    }
예제 #22
0
def bootstrapTestDB(db):
    """
        Takes an created SQLAlchemy db and bootstraps the tables
        with dummy data
    """
    books_copy, authors_copy = deepcopy(books), deepcopy(authors)

    # load authors
    for author_data in authors:
        db.session.add(Author.author_from_dict(**author_data))
    db.session.commit()

    # load genres
    for book_data in books_copy:
        for genre in book_data['genres']:
            g = Genre.query.filter_by(name=genre).first()
            if not g:
                db.session.add(Genre(genre))
                db.session.flush()
    db.session.commit()

    # load books
    for book_data in books_copy:
        book_data['genres'] = [
            Genre.query.filter_by(name=genre_item).first()
            for genre_item in book_data['genres']
        ]
        book_data['author'] = Author.query.filter_by(
            name=book_data['author']).first()
        db.session.add(Book.book_from_dict(**book_data))
    # commit the changes
    db.session.commit()

    #load users
    for author_data in authors_copy:
        author = Author.query.filter_by(name=author_data['name']).first()
        db.session.add(
            AppUser(stormpathUserHash(author_data['user_href']),
                    author_data['user_href'], author))
    db.session.commit()
예제 #23
0
    def post(self):
        user = users.get_current_user()
        action = self.request.POST.get('action')
        # En la vista de productos, se envía un campo oculto llamado 'action'
        # Este campo puede tener tres valores distintos:
        # - 'create': se crea un nuevo producto aleatoriamente y se añade al listado principal de productos.
        # - 'buy': el usuario compra un nuevo producto.
        # - 'delete': se elimina un producto del listado principal.
        if action == 'create':
            product = Product(name='p' + str(random.randint(NAME_VALUES[0], NAME_VALUES[1])),
                              cost=random.randint(PRICE_VALUES[0], PRICE_VALUES[1]))
            product.put()
        elif user:
            product = Product.get_by_id(int(self.request.POST.get('id')))
            app_user = AppUser.get_or_insert(get_user_key(user),
                                             identity=user.user_id(),
                                             email=user.email())
            if action == 'buy':
                app_user.add_product(product)

            elif action == 'delete':
                app_user.remove_product(product)
                ndb.Key(Product, product.key.id()).delete()
        self.redirect(URLS['products'])
예제 #24
0
 def test_user_pw_fail(self):
     res = self.client.post('/api/v1/user/add',data=dict(email='*****@*****.**',username='******',password='******'))
     user = AppUser.get_by_id(2)
     self.assertFalse(user.check_password('xsssxxx'))
예제 #25
0
    def testAppUser(self, ident='123', email='*****@*****.**', is_admin='0'):
        print ' --- App users tests --- '
        assert not users.get_current_user()

        self.testbed.setup_env(USER_EMAIL=email,
                               USER_ID=ident,
                               USER_IS_ADMIN=is_admin,
                               overwrite=True)

        user = users.get_current_user()

        assert user.email() == email
        assert user.user_id() == ident

        app_user = AppUser(identity=user.user_id(), email=user.email())
        assert app_user.identity == user.user_id()
        assert app_user.email == user.email()

        app_user_key = app_user.put().urlsafe()

        retrieved_app_user = get_entity_memcache(app_user_key)
        assert retrieved_app_user is not None
        assert retrieved_app_user.identity == user.user_id()
        assert retrieved_app_user.email == user.email()

        product1 = Product(name='product1', cost=1)
        product2 = Product(name='product2', cost=2)
        product3 = Product(name='product3', cost=3)
        product1_key = product1.put().urlsafe()
        product2_key = product2.put().urlsafe()
        product3_key = product3.put().urlsafe()

        retrieved_product1 = get_entity_memcache(product1_key)
        retrieved_product2 = get_entity_memcache(product2_key)
        retrieved_product3 = get_entity_memcache(product3_key)

        app_user.add_product(retrieved_product1)
        app_user.add_product(retrieved_product2)
        app_user.add_product(retrieved_product3)

        assert len(app_user.products) > 0
        assert len(app_user.products) == 3

        app_user.remove_product(retrieved_product1)
        assert len(app_user.products) > 0
        assert len(app_user.products) == 2

        app_user.remove_product(retrieved_product2)
        app_user.remove_product(retrieved_product3)

        assert len(app_user.products) == 0
 def test_add_user(self):
     count = AppUser.query.count()
     res = self.client.post('/api/v1/user/add',data=dict(email='*****@*****.**',username='******',password='******'))
     self.assertEqual(len(AppUser.get_all()),count+1)
def get_project_report(project_id):
    users = User.select().join(ProjectUser).where(ProjectUser.project == project_id)
    return jsonify({ 'users': [u.serialized for u in users] })
 def test_get_user_posts(self):
     user = AppUser.get_all()[0]
     res = self.client.post('/api/v1/user/{0}/posts'.format(user.id))
     posts = json.loads(res.get_data())
     self.assertEqual(posts,map(lambda x: x.to_json(),user.posts.all()))
 def test_user_pw_fail(self):
     res = self.client.post('/api/v1/user/add',data=dict(email='*****@*****.**',username='******',password='******'))
     print json.loads(res.get_data()).get('id')
     id = json.loads(res.get_data()).get('id')
     user = AppUser.get_by_id(id)
     self.assertFalse(user.check_password('xsssxxx'))
 def test_user_pw(self):
     res = self.client.post('/api/v1/user/add',data=dict(email='*****@*****.**',username='******',password='******'))
     user = AppUser.get_by_id(json.loads(res.get_data()).get('id'))
     self.assertTrue(user.check_password('xxxx'))
예제 #31
0
 def __subscribe_add_user(self):
     #关注获取用户信息
     openid = self.from_user
     user_info = self.appitem.get_user_info(openid)
     user = self.__get_user()
     if not user:
         user = AppUser(openid=openid)
         user.save()
     try:
         user.nickname = user_info.get('nickname')
         user.sex = user_info.get('sex')
         user.language = user_info.get('language')
         user.city = user_info.get('city')
         user.province = user_info.get('province')
         user.country = user_info.get('country')
         user.headimgurl = user_info.get('headimgurl')
         user.unionid = user_info.get('unionid')
         user.save()
     except:
         pass
     if not self.appitem.app_users.filter(openid=openid).exists():
         self.appitem.app_users.add(user)
     else:
         user.is_guanzhu = True
         user.unionid = user_info.get('unionid')
         user.save()
예제 #32
0
 def test_get_user_posts(self):
     user = AppUser.get_all()[0]
     res = self.client.post('/api/v1/user/{0}/posts'.format(user.id))
     posts = json.loads(res.get_data())
     self.assertEqual(posts, map(lambda x: x.to_json(), user.posts.all()))
예제 #33
0
def get_user_key(user):
    return str(AppUser.query(AppUser.identity == user.user_id()).get().key.id())
예제 #34
0
  def setUp(self):
    self.testbed = testbed.Testbed()
    self.testbed.activate()
    self.testbed.init_datastore_v3_stub()
    self.testbed.init_memcache_stub()

    app_credential = AppCredential(client_id='1', client_secret='secret')
    app_credential.put()

    self.new_app_user = users.User('*****@*****.**')
    self.existing_app_user = users.User('*****@*****.**')
    AppUser(user=self.existing_app_user, email='*****@*****.**',
            refresh_token='blah').put()

    # mocking webapp2 request object
    class RequestMock(object):

      def redirect(self, uri):
        return uri

    self.request_mock = RequestMock()

    # mocking handler
    @oauth2required
    def homepage_mock(request):
      return '/'
    self.homepage_mock = homepage_mock

    # helper class for mocking retry decorator
    class TestObject(object):

      def __init__(test_self):
        test_self.fails_remaining = 2

      @retry(NotImplementedError)
      def instant_success_func(test_self):
        return 'success'

      @retry(NotImplementedError)
      def eventual_success_func(test_self):
        if test_self.fails_remaining > 0:
          test_self.fails_remaining -= 1
          raise NotImplementedError()
        return 'success'

      @retry(NotImplementedError)
      def failure_func(test_self):
        raise NotImplementedError()

    self.test_obj = TestObject()
    logging.warning = mock.MagicMock(side_effect=logging.warning)

    # simulating a line item object
    self.suds_obj = suds.sudsobject.Object()
    self.suds_obj.goal = suds.sudsobject.Object()
    self.suds_obj.goal.units = 10000
    self.suds_obj.goal.goalType = 'LIFETIME'
    self.suds_obj.goal.unitType = 'IMPRESSIONS'
    self.suds_obj.orderId = 987654321
    self.suds_obj.endDateTime = suds.sudsobject.Object()
    self.suds_obj.endDateTime.date = suds.sudsobject.Object()
    self.suds_obj.endDateTime.date.year = 2015
    self.suds_obj.endDateTime.date.day = 31
    self.suds_obj.endDateTime.date.month = 12
    self.suds_obj.endDateTime.timeZoneID = 'America/New_York'
    self.suds_obj.endDateTime.second = 0
    self.suds_obj.endDateTime.hour = 23
    self.suds_obj.endDateTime.minute = 59
    self.suds_obj.reserveAtCreation = False

    def create_suds_test_obj(id_):
      obj = suds.sudsobject.Object()
      obj.id = id_
      obj.type = 'PIXEL'
      return obj
    self.suds_obj.creativePlaceholders = [
        create_suds_test_obj(0),
        create_suds_test_obj(1),
        create_suds_test_obj(2),
    ]

    self.unpacked_suds_obj = {
        'goal': {
            'units': 10000,
            'goalType': 'LIFETIME',
            'unitType': 'IMPRESSIONS',
        },
        'orderId': 987654321,
        'endDateTime': {
            'date': {
                'year': 2015,
                'day': 31,
                'month': 12,
            },
            'timeZoneID': 'America/New_York',
            'second': 0,
            'hour': 23,
            'minute': 59,
        },
        'reserveAtCreation': False,
        'creativePlaceholders': [
            {
                'id': 0,
                'type': 'PIXEL',
            },
            {
                'id': 1,
                'type': 'PIXEL',
            },
            {
                'id': 2,
                'type': 'PIXEL',
            },
        ],
    }

    # simulating a row object from PQLService
    self.cols = ['id', 'browsername']
    self.row_obj = suds.sudsobject.Object()
    self.row_obj.values = [
        suds.sudsobject.Object(),
        suds.sudsobject.Object(),
    ]
    self.row_obj.values[0].value = '123456'
    self.row_obj.values[1].value = 'Test Browser'
    self.unpacked_row_obj = {
        'id': '123456',
        'browsername': 'Test Browser',
    }