Python ItemForm.is_valid 예제들

예제 #1

파일: views.py 프로젝트: zkkmin/superlists

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():

        list_ = List.objects.create()
        form.save(for_list=list_)
        return redirect(list_)
    else:
        print(form.is_valid())
        return render(request, 'home.html', {"form":form}) 

예제 #2

파일: views.py 프로젝트: nathanbraun/superlists

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        item = Item.objects.create(text=request.POST["text"], list=list_)
        return redirect(list_)
    return render(request, "home.html", {"form": form})

예제 #3

파일: views.py 프로젝트: konradko/superlists

def view_list(request, list_id):
    list_ = List.objects.get(id=list_id)
    form = ItemForm(data=request.POST or None)
    if form.is_valid():
        form.save(for_list=list_)
        return redirect(list_)
    return render(request, "list.html", {"list": list_, "form": form})

예제 #4

파일: test_forms.py 프로젝트: rverhoev/TDD

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(
         form.errors['text'],
         [EMPTY_LIST_ERROR]
     )

예제 #5

파일: views.py 프로젝트: Yetocome/Django_test

def new_list(request):
    # list_ = List.objects.create()
    # item = Item(text=request.POST['text'], list=list_)
    # try:
    #     item.full_clean()
    #     item.save()
    # except ValidationError:
    #     list_.delete()
    #     error = "You can't have an empty list item"
    #     return render(request, 'home.html', {"error": error})
    # # return redirect('/lists/%d/' % (list_.id,))
    # return redirect('view_list', list_.id)

    # form = ItemForm(data=request.POST)
    # if form.is_valid():
    #     list_ = List.objects.create()
    #     Item.objects.create(text=request.POST['text'], list=list_)
    #     return redirect(list_)
    # else:
    #     return render(request, 'home.html', {"form": form})

    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        form.save(for_list=list_)
        return redirect(list_)
    else:
        return render(request, 'home.html', {"form": form})

예제 #6

파일: views.py 프로젝트: snoopybother/superlists

def newList(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        form.save(forList=list_)
        return redirect(list_)
    return render(request, 'lists/home.html', {'form':form})

예제 #7

파일: test_forms.py 프로젝트: MyroslavGryshyn/superlists

 def test_form_validates_blank_line(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(
         form.errors['text'],
         [EMPTY_ITEM_ERROR]
     )

예제 #8

파일: test_forms.py 프로젝트: peter14f/superlists

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(
         form.errors['text'],
         ["You can't have an empty list item"]
     )

예제 #9

파일: test_forms.py 프로젝트: ckLXHL/web_test

	def test_form_validation_for_blank_items(self):
		form = ItemForm(data={'text': ''})
		self.assertFalse(form.is_valid())
		self.assertEqual(
			form.errors['text'],
			["不能输入一个空列表项"]
		)

예제 #10

파일: views.py 프로젝트: ujuc/django_tdd

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = form.save(owner=request.user)
        return redirect(list_)
    else:
        return render(request, 'home.html', {'form': form})

예제 #11

파일: test_forms.py 프로젝트: deadlylaid/TDD_Test

 def test_case_renders_item_text_input(self):
     form = ItemForm(data={'text':''})
     self.assertFalse(form.is_valid())
     self.assertEqual(
             form.errors['text'],
             [EMPTY_LIST_ERROR]
             )

예제 #12

파일: test_forms.py 프로젝트: migglu/todo-lists

 def test_form_validation_for_blank_item(self):
     form = ItemForm(data={"text": ""})
     self.assertFalse(form.is_valid())
     self.assertEqual(
         form.errors["text"],
         [EMPTY_ITEM_ERROR]
     )

예제 #13

파일: views.py 프로젝트: el-ethan/superlists

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        Item.objects.create(text=request.POST['text'], list=list_)
        return redirect(list_)
    return render(request, 'home.html', {'form': form})

예제 #14

파일: views.py 프로젝트: bedmiston/tdd-python

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        itemlist = List.objects.create()
        form.save(for_list=itemlist)
        return redirect(itemlist)
    else:
        return render(request, 'lists/home.html', {"form": form})

예제 #15

파일: views.py 프로젝트: gyrodecl/superlists2015

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        item = form.save(for_list=list_)
        return HttpResponseRedirect(list_.get_absolute_url())
    else:
        return render(request, 'lists/home.html', {"form": form})

예제 #16

파일: views.py 프로젝트: hwy801207/django

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        form.save(for_list = list_)
        return redirect(list_)
    else:
        return render(request, 'home.html', {"form": form, "error":EMPTY_LIST_ERROR })

예제 #17

파일: views.py 프로젝트: ninetitle/Esercise-django

def new_list(request):
    form = ItemForm(data=request.POST) #si passa request.post data al costruttore del form
    if form.is_valid():                #usiamo .is_valid per determinare se l'inserzione è valida
        lista = List.objects.create()
        form.save(lista)
        return redirect(lista)
    else:
        return render(request, 'home.html',{'form' : form}) #in caso di fallimento invece di inserire una stringa di errore passiamo il form al template

예제 #18

파일: views.py 프로젝트: spncrlkt/tdd

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list = List.objects.create()
        Item.objects.create(text=request.POST['text'], list=list)
        return redirect('/lists/%d/' % (list.id,))
    else:
        return render(request, 'home.html', {"form":form})

예제 #19

파일: test_forms.py 프로젝트: RogerTangos/TestingGoat

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={'text': ''})
     # form.is_valid returns true or false, and populates the errors attr
     self.assertFalse(form.is_valid())
     self.assertEqual(
         form.errors['text'],
         ["You can't have an empty list item"]
     )

예제 #20

파일: views.py 프로젝트: devforfu/tdd

def new_list(request):
    form = ItemForm(data=request.POST)

    if form.is_valid():
        ls = List.objects.create()
        form.save(for_list=ls)
        return redirect(ls)

    return render(request, "home.html", {'form': form})

예제 #21

파일: views.py 프로젝트: martin3421/django_test

def view_list(request, list_id):
    list_ = List.objects.get(id=list_id)
    form = ItemForm()
    if request.method == "POST":
        form = ItemForm(data=request.POST)
        if form.is_valid():
            Item.objects.create(text=request.POST["text"], list=list_)
            return redirect(list_)
    return render(request, "list.html", {"list": list_, "form": form})

예제 #22

파일: views.py 프로젝트: takkaneko/superlists

def view_list(request, list_id):
    list_ = List.objects.get(id=list_id)
    form = ItemForm()
    if request.method == 'POST':
        form = ItemForm(data=request.POST)
        if form.is_valid():
            Item.objects.create(text=request.POST['text'], list=list_)
            return redirect(list_)
    return render(request,'list.html',{'list': list_,'form': form})

예제 #23

파일: views.py 프로젝트: switch87/testDrivenDevelopmentWithPython

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        #Item.objects.create(text=request.POST['text'], list=list_)
        form.save(for_list=list_)
        return redirect(list_)  # see model List
    else:
        return render(request, 'home.html', {"form": form})

예제 #24

파일: views.py 프로젝트: talister/tdd_book

def view_list(request, list_id):
    list_ = List.objects.get(id=list_id)
    form = ItemForm()
    if request.method == 'POST':
        form = ItemForm(data=request.POST)
        if form.is_valid():
            form.save(for_list=list_)
            return redirect(list_)
    return render(request, 'list.html', {'list' : list_, "form" : form})

예제 #25

파일: views.py 프로젝트: raphaeleicher/TDD_Book

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List.objects.create()
        form.save(for_list=list_)
        return redirect(list_)
    else:
        # ToDo: Remove hardcoded URLs from views.py
        return render(request, 'lists/home.html', {'form': form})

예제 #26

파일: views.py 프로젝트: syndbg-archive/tdd-app

def new_list(request):
    form = ItemForm(data=request.POST)
    if form.is_valid():
        list_ = List()
        if request.user.is_authenticated():
            list_.owner = request.user
        list_.save()
        form.save(for_list=list_)
        return redirect(list_)
    return render(request, 'home.html', {'form': form})

예제 #27

파일: views.py 프로젝트: MomomeYeah/FancyLists

def new_item(request):
    if request.method == 'POST':
        form = ItemForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            Item.objects.create_item(cd['name'])
            return HttpResponseRedirect(reverse('lists:item_index'))
    else:
        form = ItemForm()
    return render(request, 'items/new.html', {'form': form})

예제 #28

파일: views.py 프로젝트: MomomeYeah/FancyLists

def edit_item(request, item_id):
    item = get_object_or_404(Item, pk = item_id)
    if request.method == 'POST':
        form = ItemForm(request.POST, instance = item)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('lists:item_index'))
    else:
        form = ItemForm(instance = item)
    return render(request, 'items/edit.html', {'edit_item': item, 'form': form})

예제 #29

파일: test_forms.py 프로젝트: welenofsky/superlists

	def test_form_validation_for_blank_items(self):
		form = ItemForm(data={'text': ''})
		# Calling form.is_valid() returns True or False, 
		# but it also has the side effect of validating the input data, 
		# and populating the errors attribute
		self.assertFalse(form.is_valid())
		self.assertEqual(
			form.errors['text'],
			[EMPTY_LIST_ERROR]
		)

예제 #30

파일: views.py 프로젝트: nryoung/superlists

def view_list(request, list_id):
    list_ = List.objects.get(id=list_id)
    form = ItemForm(data=request.POST or None)
    if form.is_valid():
        try:
            form.save(for_list=list_)
            return redirect(list_)
        except ValidationError:
            form.errors.update({'text': "You've already got this in your list"})
    return render(request, 'list.html', {'list': list_, "form": form})

예제 #31

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid(
     ))  # checks form validation before we try to save any data
     self.assertEqual(form.errors['text'], [EMPTY_LIST_ERROR])

예제 #32

 def test_form_validation_for_empty_item(self):
     form = ItemForm(data={'text': ''})
     # form.is_valid calls form.full_clean -> validation
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [EMPTY_ITEM_ERROR])

예제 #33

 def test_form_validation_for_blank_items(self):
     list_ = List.objects.create()
     form = ItemForm(for_list=list_, data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [self.EMPTY_ITEM_ERROR])

예제 #34

파일: test_forms.py 프로젝트: marcuscaisey/goat

    def test_validation_error_for_duplicate_list_item(self, item):
        form = ItemForm({"text": item.text}, list_=item.list)

        assert not form.is_valid()
        assert form.errors["text"] == ["You can't save a duplicate item"]

예제 #35

 def test_form_validation_for_duplicate_items(self):
     list_ = List.objects.create()
     Item.objects.create(list=list_, text='no twins!')
     form = ItemForm(for_list=list_, data={'text': 'no twins!'})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [self.DUPLICATE_ITEM_ERROR])

예제 #36

 def test_form_validation(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [EMPTY_LIST_ERROR])

예제 #37

파일: test_forms.py 프로젝트: SecretCaveman/PythonTDDBook

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [EMPTY_ITEM_ERROR])

예제 #38

파일: test_forms.py 프로젝트: jonabadie/superlists

 def test_form_validation_for_duplicate_items(self):
     list1 = List.objects.create()
     Item.objects.create(text='Twin', list=list1)
     form = ItemForm(for_list=list1, data={'text': 'Twin'})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [DUPLICATE_ITEM_ERROR])

예제 #39

 def test_form_validation_for_blank_item(self):
     form = ItemForm(data={"text": ""})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors["text"], [EMPTY_ITEM_ERROR])

예제 #40

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={"text": ""})
     assert not form.is_valid()
     assert form.errors["text"] == [EMPTY_ITEM_ERROR]

예제 #41

파일: test_forms.py 프로젝트: jonabadie/superlists

 def test_form_with_list_create_item_for_that_list(self):
     list1 = List.objects.create()
     form = ItemForm(for_list=list1, data={'text': 'item'})
     self.assertTrue(form.is_valid())
     item = form.save()
     self.assertEqual(item.list, list1)

예제 #42

파일: test_forms.py 프로젝트: jonabadie/superlists

 def test_form_with_no_list_create_a_new_list(self):
     form = ItemForm(data={'text': 'First item'})
     self.assertTrue(form.is_valid())
     item = form.save()
     self.assertEqual(List.objects.count(), 1)
     self.assertEqual(item.list, List.objects.first())

예제 #43

파일: test_forms.py 프로젝트: Evgenpyrgen/GPersival

 def test_form_validation_for_blank_items(self):
     """тест валидации формы для пустых элементов"""
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [EMPTY_ITEM_ERROR])

예제 #44

 def test_form_renders_item_text_input(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'], [EMPTY_LIST_ERROR])

예제 #45

파일: test_forms.py 프로젝트: max-young/superlists

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'],
                      ["You can't have an empty list item"])

예제 #46

 def test_form_validation_for_non_empty_items(self):
     form = ItemForm(data={'text': 'text'})
     self.assertTrue(form.is_valid())
     self.assertEqual(len(form.errors), 0)

예제 #47

 def test_form_validation_for_blank_items(self) -> None:
     """Test for rejection of blank items."""
     form = ItemForm(data={"text": ""})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors["text"], [EMPTY_ITEM_ERROR])

예제 #48

 def test_form_validation_for_blank_items(self):
     form = ItemForm(data={'text': ''})
     self.assertFalse(form.is_valid())
     self.assertEqual(form.errors['text'],
                      list(ItemForm.Meta.error_messages['text'].values()))